怎么在CCS10中查看CPU Load的分析图像或者数据

图片显示不出来，请点击右下角的"使用高级编辑器编辑文本"。
另外，请问用的是哪款DSP芯片?

Hi 图片如下：

使用的芯片是C6748

请看一下是否按照CCS->Help->Help Contents->System Analyzer Help->UIA Configuration and Coding on the Target ->Quickly Enabling UIA Instrumentation的步骤配置的。

Hi 我按照你说的help文档重新配置了一下，发现还是没有数据显示出来，想请您帮忙看看这些具体的配置是否合理！谢谢！

对于打问号选项的说明：
Memory section name for the buffer managed by the static instance(default is null)

Configuration settings
LoggingSetup.memorySectionName = String null;

DETAILS

By default the local 'dataMemory' in the platform is used (typicallySRAM or L2SRAM).The available memory section names for your device can be determined byeither looking in the MEMORY CONFIGURATION section of the .map filethat is generated when you build your application or from the Platformfile that your application is using.


把.cfg文件代码贴出来看看。

.cfg文件全部代码如下：

var Defaults = xdc.useModule('xdc.runtime.Defaults');
var Diags = xdc.useModule('xdc.runtime.Diags');
var Error = xdc.useModule('xdc.runtime.Error');
var Log = xdc.useModule('xdc.runtime.Log');
var LoggerBuf = xdc.useModule('xdc.runtime.LoggerBuf');
var LoggerCallback = xdc.useModule('xdc.runtime.LoggerCallback');
var Main = xdc.useModule('xdc.runtime.Main');
var Memory = xdc.useModule('xdc.runtime.Memory')
var SysMin = xdc.useModule('xdc.runtime.SysMin');
var System = xdc.useModule('xdc.runtime.System');
var Text = xdc.useModule('xdc.runtime.Text');

var BIOS = xdc.useModule('ti.sysbios.BIOS');
var Clock = xdc.useModule('ti.sysbios.knl.Clock');
var Swi = xdc.useModule('ti.sysbios.knl.Swi');
var Task = xdc.useModule('ti.sysbios.knl.Task');
var Semaphore = xdc.useModule('ti.sysbios.knl.Semaphore');
var Hwi = xdc.useModule('ti.sysbios.hal.Hwi');
var Mailbox = xdc.useModule('ti.sysbios.knl.Mailbox');
var Queue = xdc.useModule('ti.sysbios.knl.Queue');

var ECM = xdc.useModule('ti.sysbios.family.c64p.EventCombiner');
var core = xdc.useModule('ti.sysbios.hal.Core');
var Cache = xdc.useModule('ti.sysbios.hal.Cache');

var Startup = xdc.useModule ("xdc.runtime.Startup");
var ti_sysbios_family_c64p_Cache = xdc.useModule('ti.sysbios.family.c64p.Cache');
var Timestamp = xdc.useModule('xdc.runtime.Timestamp');
var GateMutex = xdc.useModule('ti.sysbios.gates.GateMutex');

ECM.eventGroupHwiNum[0] = 7;
ECM.eventGroupHwiNum[1] = 8;

xdc.loadPackage('ti.sdo.edma3.drv.sample');

var devType = "omapl138"

/* Load the OSAL package */
var osType = "tirtos"
var Osal = xdc.useModule('ti.osal.Settings');
Osal.osType = osType;
Osal.socType = devType;

/*use CSL package*/
var Csl = xdc.loadPackage('ti.csl');
Csl.Settings.deviceType = devType;

/* Load the Board package and set the board name */
var Board = xdc.loadPackage('ti.board');
Board.Settings.boardName = "lcdkOMAPL138";

/* Load the gpio package */
var Gpio = xdc.loadPackage('ti.drv.gpio');
Gpio.Settings.enableProfiling = false;
Gpio.Settings.socType = devType;

/* Load the spi package */
var Spi = xdc.loadPackage('ti.drv.spi');
Spi.Settings.enableProfiling = false;
Spi.Settings.socType = devType;
Spi.Settings.useDma = "true";

/* Load the uart package */
var Uart = xdc.loadPackage('ti.drv.uart');
Uart.Settings.enableProfiling = false;
Uart.Settings.socType = devType;
Uart.Settings.useDma = "true";

/* Load the I2C package - required by board */
var I2c = xdc.loadPackage('ti.drv.i2c');
I2c.Settings.socType = devType;

var Edma = xdc.loadPackage ("ti.sdo.edma3.drv.sample");
var drv = xdc.loadPackage ("ti.sdo.edma3.drv");
var rm = xdc.loadPackage ("ti.sdo.edma3.rm");

//var System = xdc.useModule('xdc.runtime.System');
SysStd = xdc.useModule('xdc.runtime.SysStd');
System.SupportProxy = SysStd;

/* Load and use the CSL packages */
var Csl = xdc.useModule('ti.csl.Settings');
Csl.deviceType = devType;

/*
* Uncomment this line to globally disable Asserts.
* All modules inherit the default from the 'Defaults' module. You
* can override these defaults on a per-module basis using Module.common$.
* Disabling Asserts will save code space and improve runtime performance.
Defaults.common$.diags_ASSERT = Diags.ALWAYS_OFF;
*/

/*
* Uncomment this line to keep module names from being loaded on the target.
* The module name strings are placed in the .const section. Setting this
* parameter to false will save space in the .const section. Error and
* Assert messages will contain an "unknown module" prefix instead
* of the actual module name.
Defaults.common$.namedModule = false;
*/

/*
* Minimize exit handler array in System. The System module includes
* an array of functions that are registered with System_atexit() to be
* called by System_exit().
*/
System.maxAtexitHandlers = 4;

/*
* Uncomment this line to disable the Error print function.
* We lose error information when this is disabled since the errors are
* not printed. Disabling the raiseHook will save some code space if
* your app is not using System_printf() since the Error_print() function
* calls System_printf().
Error.raiseHook = null;
*/

/*
* Uncomment this line to keep Error, Assert, and Log strings from being
* loaded on the target. These strings are placed in the .const section.
* Setting this parameter to false will save space in the .const section.
* Error, Assert and Log message will print raw ids and args instead of
* a formatted message.
Text.isLoaded = false;
*/

/*
* Uncomment this line to disable the output of characters by SysMin
* when the program exits. SysMin writes characters to a circular buffer.
* This buffer can be viewed using the SysMin Output view in ROV.
SysMin.flushAtExit = false;
*/

/*
* The BIOS module will create the default heap for the system.
* Specify the size of this default heap.
*/
BIOS.heapSize = 0x4000;

/*
* Build a custom SYS/BIOS library from sources.
*/
BIOS.libType = BIOS.LibType_Custom;

/* System stack size (used by ISRs and Swis) */
Program.stack = 0x2000;

/* Circular buffer size for System_printf() */
SysMin.bufSize = 0x200;

/*
* Create and install logger for the whole system
*/
// Override error output color with ANSI codes, and use shorter (file.c:line) format.
Log.L_error = {
mask: Diags.STATUS,
level: Diags.ERROR,
msg: "\x1b[31;1mERROR:\x1b[0m (%s:%d) %$S"
};

Log.L_info = {
mask: Diags.INFO,
msg: "\x1b[32;1mINFO:\x1b[0m (%s:%d) %$S"
};

Log.L_warning = {
mask: Diags.STATUS,
level: Diags.WARNING,
msg: "\x1b[33;1mWARNING:\x1b[0m (%s:%d) %$S"
};
LoggerCallback.outputFxn = "&loggerOutput"
var loggerParams = new LoggerCallback.Params();
loggerParams.arg = 1;
Main.common$.diags_INFO = Diags.ALWAYS_ON;
Defaults.common$.logger = LoggerCallback.create(loggerParams);

System.SupportProxy = SysMin;

var clock0Params = new Clock.Params();
clock0Params.instance.name = "CLK_PRD10ms";
clock0Params.period = 10;
clock0Params.arg = 10;
clock0Params.startFlag = true;
Program.global.CLK_PRD10ms = Clock.create("&SemPost", 5, clock0Params);
var clock1Params = new Clock.Params();
clock1Params.instance.name = "CLK_PRD1Hz";
clock1Params.startFlag = true;
clock1Params.period = 1000;
clock1Params.arg = 1000;
Program.global.CLK_PRD1Hz = Clock.create("&SemPost", 5, clock1Params);
var swi0Params = new Swi.Params();
swi0Params.instance.name = "SWI1KHz";
swi0Params.priority = 10;
Program.global.SWI1KHz = Swi.create("&Swi1KHzExecute", swi0Params);
var task0Params = new Task.Params();
task0Params.instance.name = "TSK_PRD1Hz";
task0Params.priority = 3;
Program.global.TSK_PRD1Hz = Task.create("&Prd1HzTask", task0Params);
var task1Params = new Task.Params();
task1Params.instance.name = "TSK_PRD10ms";
task1Params.stackSize = 2048;
Program.global.TSK_PRD10ms = Task.create("&Prd10msTask", task1Params);

var task2Params = new Task.Params();
task2Params.instance.name = "TSK_1KHz";
task2Params.priority = 6;
Program.global.TSK_1KHz = Task.create("&Tsk1KHzExecute", task2Params);

var semaphore2Params = new Semaphore.Params();
semaphore2Params.instance.name = "TSK1KHzSEM";
semaphore2Params.mode = Semaphore.Mode_BINARY;
Program.global.TSK1KHzSEM = Semaphore.create(null, semaphore2Params);

var semaphore0Params = new Semaphore.Params();
semaphore0Params.instance.name = "PRD10msSEM";
Program.global.PRD10msSEM = Semaphore.create(null, semaphore0Params);
var semaphore1Params = new Semaphore.Params();
semaphore1Params.instance.name = "PRD1KHzSEM";
Program.global.PRD1KHzSEM = Semaphore.create(null, semaphore1Params);

Clock.timerId = 0;
var swi1Params = new Swi.Params();
swi1Params.instance.name = "hSysInfoSetSwi";
Program.global.hSysInfoSetSwi = Swi.create("&WrapSysinfo_swiNotifySubscriber", swi1Params);
var queue0Params = new Queue.Params();
queue0Params.instance.name = "sysinfoNotifMem";
Program.global.sysinfoNotifMem = Queue.create(queue0Params);
var queue1Params = new Queue.Params();
queue1Params.instance.name = "sysinfoNotifQue";
Program.global.sysinfoNotifQue = Queue.create(queue1Params);
var task3Params = new Task.Params();
task3Params.instance.name = "uartTxTask";
task3Params.priority = 3;
Program.global.uartTxTask = Task.create("&uartTxTaskFunc", task3Params);
var semaphore3Params = new Semaphore.Params();
semaphore3Params.instance.name = "uartTxSem";
semaphore3Params.mode = Semaphore.Mode_BINARY;
Program.global.uartTxSem = Semaphore.create(null, semaphore3Params);
var task4Params = new Task.Params();
task4Params.instance.name = "debugScreenTask";
Program.global.debugScreenTask = Task.create("&debugScreenTaskFunc", task4Params);
var swi2Params = new Swi.Params();
swi2Params.instance.name = "hCanTxSwi";
Program.global.hCanTxSwi = Swi.create("&CANDATAtxHandler", swi2Params);
var mailbox0Params = new Mailbox.Params();
mailbox0Params.instance.name = "hML2RxMbx";
Program.global.hML2RxMbx = Mailbox.create(17, 100, mailbox0Params);

ti_sysbios_family_c64p_Cache.initSize.l2Size = ti_sysbios_family_c64p_Cache.L2Size_128K;
ti_sysbios_family_c64p_Cache.initSize.l1pSize = ti_sysbios_family_c64p_Cache.L1Size_32K;
ti_sysbios_family_c64p_Cache.initSize.l1dSize = ti_sysbios_family_c64p_Cache.L1Size_32K;
ti_sysbios_family_c64p_Cache.MAR192_223 = 128;
ti_sysbios_family_c64p_Cache.MAR0_31 = 0;
var hwi0Params = new Hwi.Params();
hwi0Params.instance.name = "canDataHwi";
hwi0Params.eventId = 62;
Program.global.canDataHwi = Hwi.create(9, "&CANDATAintHandler", hwi0Params);
var mailbox1Params = new Mailbox.Params();
mailbox1Params.instance.name = "ML2ECPEMBX0";
Program.global.ML2ECPEMBX0 = Mailbox.create(14, 100, mailbox1Params);
var mailbox2Params = new Mailbox.Params();
mailbox2Params.instance.name = "ML2ECPEMBX1";
Program.global.ML2ECPEMBX1 = Mailbox.create(14, 100, mailbox2Params);
var mailbox3Params = new Mailbox.Params();
mailbox3Params.instance.name = "ML2ECPEMBX2";
Program.global.ML2ECPEMBX2 = Mailbox.create(14, 100, mailbox3Params);
var mailbox4Params = new Mailbox.Params();
mailbox4Params.instance.name = "ML2ECPEMBX3";
Program.global.ML2ECPEMBX3 = Mailbox.create(14, 100, mailbox4Params);
var mailbox5Params = new Mailbox.Params();
mailbox5Params.instance.name = "ML2ECPEMBX4";
Program.global.ML2ECPEMBX4 = Mailbox.create(14, 100, mailbox5Params);
var mailbox6Params = new Mailbox.Params();
mailbox6Params.instance.name = "ML2ECPEMBX5";
Program.global.ML2ECPEMBX5 = Mailbox.create(14, 100, mailbox6Params);
var mailbox7Params = new Mailbox.Params();
mailbox7Params.instance.name = "ML2ECPEMBX6";
Program.global.ML2ECPEMBX6 = Mailbox.create(14, 100, mailbox7Params);
var mailbox8Params = new Mailbox.Params();
mailbox8Params.instance.name = "ML2ECPEMBX7";
Program.global.ML2ECPEMBX7 = Mailbox.create(14, 100, mailbox8Params);
var gateMutextParams = new GateMutex.Params;
Program.global.hML2StreamWatchdogMutex = GateMutex.create(gateMutextParams);
Program.global.hFtpSessionMutex = GateMutex.create(gateMutextParams);
var mailbox9Params = new Mailbox.Params();
mailbox9Params.instance.name = "FTPProcessMBX";
Program.global.FTPProcessMBX = Mailbox.create(40, 200, mailbox9Params);
var queue2Params = new Queue.Params();
queue2Params.instance.name = "ftpReqQueMem";
Program.global.ftpReqQueMem = Queue.create(queue2Params);
var queue3Params = new Queue.Params();
queue3Params.instance.name = "ftpReqQue";
Program.global.ftpReqQue = Queue.create(queue3Params);
var semaphore4Params = new Semaphore.Params();
semaphore4Params.instance.name = "SEMML2data";
semaphore4Params.mode = Semaphore.Mode_BINARY;
Program.global.SEMML2data = Semaphore.create(1, semaphore4Params);

var task9Params = new Task.Params();
task9Params.instance.name = "TSK_2KHz";
task9Params.priority = 7;
Program.global.TSK_2KHz = Task.create("&Tsk1KHzExecute", task9Params);

var semaphore4Params = new Semaphore.Params();
semaphore4Params.instance.name = "TSK2KHzSEM";
semaphore4Params.mode = Semaphore.Mode_BINARY;
Program.global.TSK2KHzSEM = Semaphore.create(null, semaphore4Params);

谢谢啦！