/* 初始化所有任务的 TSK_Attrs 结构 */
	TSK_Attrs tsk0_attrs = {0};
	TSK_Attrs tsk1_attrs = {0};
	TSK_Attrs tsk2_attrs = {0};
	TSK_Attrs lltask_attrs = {0};
	TSK_Attrs cleanup_attrs = {0};
 
LOG_printf(&trace, "Faraday Test example started.\n");
 
	/* 启动 PRD 时钟 */
	PRD_start(&PRD0);
 
 
	/* 创建 Task0 */
	tsk0_attrs.name = "Task0";
	tsk0_attrs.priority = 2;
	tsk0_attrs.stacksize = 512;
	tsk0_attrs.stack = NULL;
	tsk0_attrs.initstackflag = 1;
	hTask0 = TSK_create((Fxn)task0, &tsk0_attrs);
	if (!hTask0) 
	{
		SYS_abort("Can't create task 0");
	}
 
	/* 创建 Task1 */
	tsk1_attrs.name = "Task1";
	tsk1_attrs.priority = 2;
	tsk1_attrs.stacksize = 512;
	tsk1_attrs.stack = NULL;
	tsk1_attrs.initstackflag = 1;
	hTask1 = TSK_create((Fxn)task1, &tsk1_attrs);
	if (!hTask1) 
	{
		SYS_abort("Can't create task 1");
	}
 
	/* 创建 Task2 */
	tsk2_attrs.name = "Task2";
	tsk2_attrs.priority = 2;
	tsk2_attrs.stacksize = 512;
	tsk2_attrs.stack = NULL;
	tsk2_attrs.initstackflag = 1;
	hTask2 = TSK_create((Fxn)task2, &tsk2_attrs);
	if (!hTask2) 
	{
		SYS_abort("Can't create task 2");
	}
 
	/* 创建低级别任务 */
	lltask_attrs.name = "LowLevel Task";
	lltask_attrs.priority = 1;
	lltask_attrs.stacksize = 512;
	lltask_attrs.stack = NULL;
	lltask_attrs.initstackflag = 1;
	hllTask = TSK_create((Fxn)lltask, &lltask_attrs);
	if (!hllTask) 
	{
		SYS_abort("Can't create low level task");
	}
 
	/* 创建清除任务 */
	cleanup_attrs.name = "Cleanup Task";
	cleanup_attrs.priority = 3;
	cleanup_attrs.stacksize = 512;
	cleanup_attrs.stack = NULL;
	cleanup_attrs.initstackflag = 1;
	cleanupTask = TSK_create((Fxn)cleanup, &cleanup_attrs);
	if (!hllTask) 
	{
		SYS_abort("Can't create CleanUp task");
	}

/* 设置 ETB 接收器 */
	etbError = ETB_open(pETBErrCallBack, eETB_Circular, coreID, &pETBHandle, &etbSize);
	if(etbError != eETB_Success)
	{
		SYS_abort("Error opening ETB");
	} else {
		LOG_printf(&trace, "ETB Opened");
	}
 
		/* 启用 ETB 接收器 */
	etbError = ETB_enable(pETBHandle, 0);
	if(etbError != eETB_Success)
	{
		SYS_abort("Error enabling ETB");
	} else {
		LOG_printf(&trace, "ETB Enabled");
	}
 
 
	/* 在此处应完成 AETLIB 编程 */
 
	/* 配置 AET 以便在 task0 函数处启动，
	   并在自定义 myExit 函数处结束
	*/
 
	startTraceParams = AET_JOBPARAMS;
	endTraceParams = AET_JOBPARAMS;
 
	startTraceParams.programAddress = (Uint32)&task0;
	startTraceParams.traceTriggers = AET_TRACE_TIMING | AET_TRACE_PA;
	startTraceParams.traceActive = AET_TRACE_ACTIVE;
 
	endTraceParams.programAddress = (Uint32) &myExit;
	endTraceParams.traceTriggers = AET_TRACE_TIMING | AET_TRACE_PA;
	endTraceParams.traceActive = AET_TRACE_INACTIVE;
 
	AET_init();
 
	if (AET_claim()){
		SYS_abort("AET not claimed");
	}else{
		LOG_printf(&trace, "AET Claimed");
	}
 
	/* 设置跟踪开始任务 */
	if (AET_setupJob(AET_JOB_START_STOP_TRACE_ON_PC, &startTraceParams)){
		SYS_abort("Start job program failure");
	}else{
		LOG_printf(&trace, "Start Job Programmed Success");
	}
 
	startJob = startTraceParams.jobIndex;
 
	LOG_printf(&trace, "Start Job #%d", startJob);
 
	/* 设置跟踪结束任务 */
	if (AET_setupJob(AET_JOB_START_STOP_TRACE_ON_PC, &endTraceParams)){
		SYS_abort("End job program failure");
	}else{
		LOG_printf(&trace, "End Job Programmed Success");
	}
 
	endJob = endTraceParams.jobIndex;
 
	LOG_printf(&trace, "End Job #%d", endJob);
 
	/* 启用 AET */
	if (AET_enable()){
		SYS_abort("Error Enabling AET");
	}else{
		LOG_printf(&trace, "AET Enabled");
	}
 
 
	/*** 设置跟踪导出 ***/
	/* 打开 DSP 跟踪导出模块 */
	dspTraceError = DSPTrace_open( pDSPErrorCallBack, &pDSPHandle);
	if(dspTraceError != eDSPTrace_Success)
	{
		SYS_abort("Error opening DSP Trace Export block");
	}else{
		LOG_printf(&trace, "Trace Export Opened");
	}
 
	/* 将跟踪导出时钟设置为 FCLK/2 */
	dspTraceError= DSPTrace_setClock(pDSPHandle, 2);
	if(dspTraceError != eDSPTrace_Success)
	{
		SYS_abort("Error setting up DSP trace export clock");
	}else{
		LOG_printf(&trace, "Trace Clock Initialized");
	}
 
	/* 启用 DSP 跟踪 */
	dspTraceError= DSPTrace_enable(pDSPHandle, 0, testPattern);
 
	if(dspTraceError != eDSPTrace_Success)
	{
		SYS_abort("Error enabling DSP trace export");
	} else {
		LOG_printf(&trace, "DSP Trace Enabled");
	}
 
	/* 启动 PRD 时钟 */
	PRD_start(&PRD0);

void dumpEtb(){
 
 
	// 释放所有 AETLIB 资源
	AET_releaseJob(startJob);
	AET_releaseJob(endJob);
	AET_release();	
 
	// 禁用跟踪导出
	dspTraceError = DSPTrace_disable(pDSPHandle);
	if (dspTraceError == eDSPTrace_Success) {
		statusCode |= STS_TRACE_EXPORT_DISABLED;
	}
 
	/* 禁用跟踪捕获 - ETB 接收器 */
	etbError = ETB_disable(pETBHandle);
	if (etbError == eETB_Success){
		statusCode |= STS_ETB_DISABLED;
	}
 
	/* 检查 ETB 状态 */
	etbError = ETB_status(pETBHandle, &etbStatus);
	if (etbError == eETB_Success){
		statusCode |= STS_ETB_STATUS;
	}
 
	/* 将 ETB 数据移动到内存 */
	if (etbStatus.canRead == 1)
	{
		etbWordsAvailable = etbStatus.availableWords;
		if (etbStatus.isWrapped == 1){
			statusCode |= STS_ETB_WRAPPED;
		}else{
			statusCode |= STS_ETB_NOT_WRAPPED;
		}
 
		/* 
		 * 分配缓冲区以便将 ETB 复制到其中
		 * 将 memPtr 设置为之前静态分配的数组
		 */ 
		memPtr = (uint32_t*)&etb_buf;
 
		if (memPtr)
		{
			etbError = ETB_read(pETBHandle, memPtr, etbStatus.availableWords, 0, etbStatus.availableWords, &retSize);
 
			if (etbError == eETB_Success)
			{
				statusCode |= STS_ETB_READ;
			}
			statusCode |= STS_BUF_ALLOCATE;
		}
	}
 
 
	/* 关闭 ETB 的句柄 */
	etbError = ETB_close(pETBHandle);
 
	if (etbError == eETB_Success)
	{
		statusCode |= STS_ETB_CLOSED;
	}	
 
	/* 关闭 DSPTrace 的句柄 */
	dspTraceError = DSPTrace_close(pDSPHandle);
	if (dspTraceError == eDSPTrace_Success)
	{
		statusCode |= STS_TRACE_EXPORT_CLOSED;
	}
 
}

saveRaw(startAddr, PAGE_PROGRAM, "C:\\temp\\etb_test.bin", length , 32, true)