C6748下Task线程的使用

各位开发者：

    大家好。我在C6748的开发板上编写BIOS下的UART读写程序，我的思路如下：

    1. 在main函数中创建Task_Handle对象myTsk0；

    2. 在myTsk0对应的Task处理函数uartSampleTask中进行UART的配置，并调用GIO_write/read()进行数据的读写；

    3. 运行一个Idle循环，在对应的函数中删除myTsk0，然后退出；

在调试的过程中发生一个问题，在uartSampleTask()函数中调用GIO_write/read()时，程序会忽然退出，然后进入idle循环中，这是怎么回事？

程序的源代码如下：

uartSample_main.c

#include <xdc/std.h>
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/io/GIO.h>
#include <xdc/runtime/log.h>
#include <ti/sysbios/knl/Task.h>
#include <xdc/runtime/Error.h>
#include <xdc/runtime/System.h>
#include <ti/sdo/edma3/drv/edma3_drv.h>

#include <psc/include/Psc.h>
#include <uart/include/Uart.h>
#include <uart/include/UartLocal.h>
#include <platforms/evm6748/Uart_evmInit.h>

#include <stdio.h>

Task_Handle myTsk0;
Int myHookSetId;

Void startUartSample(Void);
EDMA3_DRV_Handle edma3init(unsigned int edma3Id, EDMA3_DRV_Result *);

#define UART_NUM_IOP (1u)

Void uartSampleTask(UArg arg1, UArg arg2);
static Void uartEdmaInit(Void);
static Void tskHeartBeat(Void);
Void myRegister(int hookSetId);
Void myCreate(Task_Handle task, Error_Block* eb);
Void myReady(Task_Handle task);
Void myExit(Task_Handle task);
Void myDelete(Task_Handle task);

EDMA3_DRV_Handle hEdma;
GIO_Handle uartRxHandle;

GIO_Handle uartTxHandle;

Uart_Params uartParams;

void user_uart_init(void);

Void main(Void)
{
System_printf("\r\nUart Sample Main\n");

/* Call the EVM specific initialization function */
configureUart();
// 动态创建任务
Task_Params params;
Error_Block eb;

Error_init(&eb);
Task_Params_init(&params);

params.instance->name = "myTsk0";
myTsk0 = Task_create(uartSampleTask, &params, &eb);

if (myTsk0 == NULL)
{
System_abort("myTsk0 create failed\n");
}
BIOS_start();

return;
}

Void uartSampleTask(UArg arg1, UArg arg2)
{
Uart_ChanParams chanParams;
Error_Block eb;
GIO_Params ioParams;

Error_init(&eb);

GIO_Params_init(&ioParams);

uartEdmaInit();

chanParams.hEdma = hEdma;
ioParams.chanParams = (Ptr)&chanParams;

uartTxHandle = GIO_create("/uart2", GIO_OUTPUT, &ioParams, &eb);
uartRxHandle = GIO_create("/uart2",GIO_INPUT, &ioParams, &eb);

if ((NULL == uartRxHandle) || (NULL == uartTxHandle))
{
System_printf("\nStream creation failed\n");
}
else
{

startUartSample();

tskHeartBeat();

}

System_printf("\nuartSampleTask任务函数执行完毕\n");
}

static Void uartEdmaInit(Void)
{
EDMA3_DRV_Result edmaResult = 0;

hEdma = edma3init(0, &edmaResult);
if (edmaResult != EDMA3_DRV_SOK)
{
/* Report EDMA Error */
System_printf("\nEDMA driver initialization FAIL\n");
}
else
{
System_printf("\nEDMA driver initialization PASS.\n");
}
}

/*
* UART0 init function called when creating the driver.
*/

// 在uartSample.cfg配置文件中的initFxn变量中设置
void user_uart_init()
{
Uart_init();

uartParams = Uart_PARAMS;
uartParams.opMode = Uart_OpMode_POLLED;
uartParams.baudRate = Uart_BaudRate_115_2K;
uartParams.hwiNumber = 9;
uartParams.rxThreshold = Uart_RxTrigLvl_1;
uartParams.softTxFifoThreshold = 1;

if(Uart_OpMode_POLLED == uartParams.opMode)
{
System_printf("\r\nUart is configured in polled mode");
}
else if (Uart_OpMode_INTERRUPT == uartParams.opMode)
{
System_printf("\r\nUart is configured in interrupt mode");
}
else if (Uart_OpMode_DMAINTERRUPT == uartParams.opMode)
{
System_printf("\r\nUart is configured in dma mode");
}
else
{
System_printf("\r\nError: Unknown mode of operation!!!!!!!!!!");
}
}

/**
* \brief Function to print an log to the console every one second(Approx)
*
* \param None
*
* \return None
*
*/

/*
static Void tskHeartBeat()
{
int count = 0;
printf("tskHeartBeat Execute 1\n");
++count;
}
*/

static Void tskHeartBeat()
{
static Uint32 counter = 0;
// printf("tskHeartBeat Execute 1\n");

/*
while (counter < 0xFFFFFFFF)
{
// System_printf("tskHeartBeat Execute 2\n");
Task_sleep(1000u);
// System_printf("tskHeartBeat Execute 3\n");
System_printf("\r\n\r\n!!! PSP HrtBt %l", counter);
counter++;
}
*/
while (counter < 0x5)
{
Task_sleep(1000u);

System_printf("\r\n\r\n!!! PSP HrtBt %l", counter);
counter++;
}
}

Void myIdleFunc()
{
System_printf("Entering idleFunc().\n");

Task_delete(&myTsk0);
System_exit(0);
}

Void myRegister(int hookSetId)
{
System_printf("myRegister: assigned HookSet Id = %d\n", hookSetId);
myHookSetId = hookSetId;
}

Void myCreate(Task_Handle task, Error_Block* eb)
{
String name;
Ptr pEnv;

name = Task_Handle_name(task);
pEnv = Task_getHookContext(task, myHookSetId);

System_printf("myCreate: task name = '%s', pEnv = 0x%x\n", name, pEnv);
Task_setHookContext(task, myHookSetId, (Ptr)0xdead);
}

Void myReady(Task_Handle task)
{
String name;
Ptr pEnv;

name = Task_Handle_name(task);
pEnv = Task_getHookContext(task, myHookSetId);

System_printf("myCreate: task name = '%s', pEnv = 0x%x\n", name, pEnv);
Task_setHookContext(task, myHookSetId, (Ptr)0xc0de);
}

Void myExit(Task_Handle task)
{
Task_Handle curTask = task;
String name;
Ptr pEnv;

name = Task_Handle_name(curTask);
pEnv = Task_getHookContext(curTask, myHookSetId);

System_printf("myCreate: curTask name = '%s', pEnv = 0x%x\n", name, pEnv);
Task_setHookContext(curTask, myHookSetId, (Ptr)0xdeadbeef);
}

Void myDelete(Task_Handle task)
{
String name;
Ptr pEnv;

name = Task_Handle_name(task);
pEnv = Task_getHookContext(task, myHookSetId);

System_printf("myDelete: task name = '%s', pEnv = 0x%x\n", name, pEnv);
}

uartSample_io.c

#include <xdc/std.h>
#include <string.h>
#include <xdc/runtime/Memory.h>
#include <xdc/runtime/Log.h>
#include <xdc/runtime/Error.h>
#include <xdc/runtime/System.h>
#include <xdc/runtime/log.h>
#include <ti/sysbios/knl/task.h>

#include <ti/sysbios/io/GIO.h>
#include <psc/include/Psc.h>
#include <uart/include/Uart.h>
#include <uart/include/UartLocal.h>
#include <platforms/evm6748/Uart_evmInit.h>

extern GIO_Handle uartRxHandle;

extern GIO_Handle uartTxHandle;

#define SIZEOF_UART_START_STRING 100

#pragma DATA_ALIGN(uartTestStringStart, 128);
static char uartTestStringStart[SIZEOF_UART_START_STRING];

#pragma DATA_ALIGN(uartBuffer, 128);
// static char uartBuffer[1000];
static char uartBuffer[10];

Void startUartSample(Void)
{
size_t len = 0;
char *string = NULL;
Int status = IOM_COMPLETED;

string = "UART Demo Starts: INPUT a file of size 1000 bytes";

strcpy(uartTestStringStart,string);

len = strlen(uartTestStringStart);

/* Transmit the string */
status = GIO_write(uartTxHandle,&uartTestStringStart,&len);
if (IOM_COMPLETED != status)
{
System_printf("\r\nGIO_write failed. returned : %d", status); }

/* Now the user will input a string of 1000 bytes. Hence submit a read *
* request for 1000 bytes */
len = 1000u;

status = GIO_read(uartRxHandle,&uartBuffer,&len);
if (IOM_COMPLETED != status)
{
System_printf("\r\nGIO_read failed. returned : %d", status); }

/* Echo the input data to User for verification */
len = 1000u;

/* Wait until all submit requests completed */
Task_sleep(1);

status = GIO_write(uartTxHandle,&uartBuffer,&len);
if (IOM_COMPLETED != status)
{
System_printf("\r\nGIO_write failed. returned : %d", status); }
}

配置文件如下：

uartSample.cfg

/*use modules*/
var GIO = xdc.useModule('ti.sysbios.io.GIO');
var Task = xdc.useModule ("ti.sysbios.knl.Task");
var BIOS = xdc.useModule ("ti.sysbios.BIOS");
var ECM = xdc.useModule ("ti.sysbios.family.c64p.EventCombiner");
var timestamp = xdc.useModule ("xdc.runtime.Timestamp");
var Cache = xdc.useModule ("ti.sysbios.hal.Cache");
var Semaphore = xdc.useModule ("ti.sysbios.knl.Semaphore");
var Hwi = xdc.useModule ("ti.sysbios.family.c64p.Hwi");
var Swi = xdc.useModule ("ti.sysbios.knl.Swi");
var Assert = xdc.useModule('xdc.runtime.Assert');
var Log = xdc.useModule('xdc.runtime.Log');
var LoggerBuf = xdc.useModule('xdc.runtime.LoggerBuf');
var Memory = xdc.useModule('xdc.runtime.Memory')
var SysMin = xdc.useModule('xdc.runtime.SysMin');
var System = xdc.useModule('xdc.runtime.System');
var SysStd = xdc.useModule('xdc.runtime.SysStd');
var Defaults = xdc.useModule('xdc.runtime.Defaults');
var Main = xdc.useModule('xdc.runtime.Main');
var Diags = xdc.useModule('xdc.runtime.Diags');

Main.common$.diags_ASSERT = Diags.ALWAYS_ON;
Main.common$.diags_INTERNAL = Diags.ALWAYS_ON;

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

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

System.SupportProxy = SysStd;

SysMin.bufSize = 4096;

/* * Create and install logger for the whole system
*/
var loggerBufParams = new LoggerBuf.Params();
loggerBufParams.numEntries = 32;
var logger0 = LoggerBuf.create(loggerBufParams);
Defaults.common$.logger = logger0;
Main.common$.diags_INFO = Diags.ALWAYS_ON;

var Idle = xdc.useModule('ti.sysbios.knl.Idle');
Idle.addFunc('&myIdleFunc');

/*
* Task.enableIdleTask = false;
* Task.allBlockedFunc = Idle.run;
*/

var iomFxns = "Uart_IOMFXNS";
var initFxn = "user_uart_init";
var deviceParams = "uartParams";
var deviceId = 2;
GIO.addDeviceMeta("/uart2", iomFxns, initFxn, deviceId, deviceParams);

Task.common$.namedInstance = true;

Task.addHookSet({
registerFxn: '&myRegister',
createFxn: '&myCreate',
readyFxn: '&myReady',
exitFxn: '&myExit',
deleteFxn: '&myDelete',
}
);

Tony Tang：

没必要这么麻烦，在main里，或者任务的主循环之间初始化UART即可，也没必要用GIO，SIO之类的驱动接口。