Int32 fxnTest1(UInt32 size, UInt32 *data)
{
FxnArgs *args = (FxnArgs *)((UInt32)data + sizeof(map_info_type));
t1.buffer1 = t2.buffer1 = (int*)(args->a) ;
t1.buffer2 = t2.buffer2 = (int*)(args->b) ;
t1.buffer3 = t2.buffer3 = (int*)(args->c) ;
t1.start_indx = t2.start_indx = args->start_indx;
t1.end_indx = t2.end_indx = args->end_indx;
int unit_work = (t2.end_indx - t1.start_indx)/2 ;
t1.end_indx = t1.start_indx + unit_work ;
t2.start_indx = t2.start_indx + unit_work ;
task0 = Task_create((Task_FuncPtr)common_wrapper, &taskParams0, &eb0);
if (task0 == NULL) {
System_abort("Task create failed");
}
task1 = Task_create((Task_FuncPtr)common_wrapper, &taskParams1, &eb1);
if (task1 == NULL) {
// System_abort("Task create failed");
}
UInt events ;
events = Event_pend(edgeDetectEvent, Event_Id_00 + Event_Id_01, Event_Id_NONE, BIOS_WAIT_FOREVER) ;
Task_delete(&task0) ;
Task_delete(&task1) ;
Uint32 reta = 1 ;
return reta ;
}
/*!
* ======== OffloadM3_init ========
*
* Initialize the OffloadM3 module, currently supported only on SysM3
*/
Void OffloadM3_init()
{
Task_Params taskParams;
Semaphore_Params mutexParams;
sysm3ProcId = MultiProc_getId("CORE0");
if (MultiProc_self() != sysm3ProcId)
return;
Semaphore_Params_init(&mutexParams);
mutexParams.mode = Semaphore_Mode_BINARY;
module.mutex = Semaphore_create(1, NULL, NULL);
module.created = FALSE;
module.semaphores[OFFLOAD_CREATE_IDX] = Semaphore_create(0, NULL, NULL);
module.semaphores[OFFLOAD_DELETE_IDX] = Semaphore_create(0, NULL, NULL);
Task_Params_init(&taskParams);
taskParams.instance->name = "OffloadM3_createTask";
taskParams.priority = xdc_runtime_knl_Thread_Priority_NORMAL;
taskParams.arg0 = (UArg)module.semaphores[OFFLOAD_CREATE_IDX];
module.tasks[OFFLOAD_CREATE_IDX] = Task_create(OffloadM3_createTask, &taskParams, NULL);
Task_Params_init(&taskParams);
taskParams.instance->name = "OffloadM3_deleteTask";
taskParams.priority = xdc_runtime_knl_Thread_Priority_HIGHEST;
taskParams.arg0 = (UArg)module.semaphores[OFFLOAD_DELETE_IDX];
module.tasks[OFFLOAD_DELETE_IDX] = Task_create(OffloadM3_deleteTask, &taskParams, NULL);
}
void A110x2500Radio::begin(uint8_t address, channel_t channel, power_t power)
{
gDataTransmitting = false;
gDataReceived = false;
Task_Params taskParams;
Error_Block eb;
Error_init(&eb);
GateMutex_construct(&mygate, NULL);
sem = Semaphore_create(0, NULL, &eb);
// Configure the radio and set the default address, channel, and TX power.
A110LR09Init(&gPhyInfo, &gSpi, gGdo);
setAddress(address);
setChannel(channel);
setPower(power);
Task_Params_init(&taskParams);
taskParams.priority = Task_numPriorities - 1;
taskParams.stackSize = 0x800;
Task_create(serviceInterrupt, &taskParams, &eb);
attachInterrupt(RF_GDO0, gdo0Isr, FALLING);
sleep();
}
int8_t BtStack_start(void)
{
if (rxTask != NULL)
{
// service already started
return -1;
}
// creating the task
Task_Params params;
Task_Params_init(¶ms);
params.instance->name = "btStack::rx";
params.priority = rxPriority;
params.stackSize = rxStackSize;
Error_Block eb;
Error_init(&eb);
rxTask = Task_create((Task_FuncPtr) rxFxn, ¶ms, &eb);
if (rxTask == NULL)
{
return -2;
}
else
{
hasStart = TRUE;
return 0;
}
}
/*
* ======== main ========
*/
Void main()
{
Swi_Params swiParams;
Task_Params taskParams;
Clock_Params clkParams;
Swi_Params_init(&swiParams);
swiParams.arg0 = 1;
swiParams.arg1 = 0;
swiParams.priority = 2;
swiParams.trigger = 0;
swi0 = Swi_create(swi0Fxn, &swiParams, NULL);
swiParams.arg0 = 2;
swiParams.arg1 = 0;
swiParams.priority = 1;
swiParams.trigger = 3;
swi1 = Swi_create(swi1Fxn, &swiParams, NULL);
Task_Params_init(&taskParams);
taskParams.priority = 1;
Task_create (tsk0Fxn, &taskParams, NULL);
Clock_Params_init(&clkParams);
clkParams.startFlag = TRUE;
Clock_create(clk0Fxn, 2, &clkParams, NULL);
sem0 = Semaphore_create(0, NULL, NULL);
BIOS_start();
}
void netOpenHook(UArg uarg0)
{
Task_Handle taskHandle;
Task_Params taskParams;
Error_Block eb;
/* Make sure Error_Block is initialized */
Error_init(&eb);
/*
* Create the Task that farms out incoming TCP connections.
* arg0 will be the port that this task listens to.
*/
Task_Params_init(&taskParams);
taskParams.stackSize = UDPHANDLERSTACK;
taskParams.priority = 1;
taskParams.arg0 = UDPPORT;
//mbox
taskParams.arg1 = uarg0;
taskHandle = Task_create((Task_FuncPtr)udpHandler, &taskParams, &eb);
if (taskHandle == NULL) {
System_printf("netOpenHook: Failed to create tcpHandler Task\n");
}
System_flush();
}
/*
* ======== netOpenHook ========
* NDK network open hook used to initialize IPv6
*/
void netOpenHook()
{
Task_Handle taskHandle;
Task_Params taskParams;
Error_Block eb;
int status;
int dev_index = 1;
/* Make sure Error_Block is initialized */
Error_init(&eb);
status = IPv6InterfaceInit(dev_index, IPv6DADStatus);
if (status < 0) {
System_printf("Error %d: failed to add IPv6 interface\n", status);
}
/*
* Create the Task that handles UDP "connections."
* arg0 will be the port that this task listens to. arg1 is the family,
* set for IPv6 in this example.
*/
Task_Params_init(&taskParams);
taskParams.stackSize = UDPHANDLERSTACK;
taskParams.priority = 1;
taskParams.arg0 = UDPPORT;
taskParams.arg1 = AF_INET6;
taskHandle = Task_create((Task_FuncPtr)echoFxn, &taskParams, &eb);
if (taskHandle == NULL) {
System_printf("Error: Failed to create udpHandler Task\n");
}
}
/*
* setup task function
*/
int setup_Blink_Task( UArg mbox)
{
Task_Params taskLedParams;
Task_Handle taskLed;
/* Errorblock beinhält daten über grund des Fehlers bei Taskcreation
*/
Error_Block eb;
/* Create Blink task with priority 15*/
Error_init(&eb);
Task_Params_init(&taskLedParams);
taskLedParams.stackSize = 1024;/*stack in bytes*/
taskLedParams.priority = 15;/*0-15 default 16 is highest priority -> see RTOS configuration*/
taskLedParams.arg0 = mbox;
taskLed = Task_create((Task_FuncPtr)BlinkFxn, &taskLedParams, &eb);
if (taskLed == NULL) {
System_abort("TaskLed create failed");
}
return (0);
}
/*
* ======== main ========
*/
Int main(Int argc, Char* argv[])
{
Error_Block eb;
Task_Params taskParams;
Log_print0(Diags_INFO, LOGSTR(1));
/* must initialize the error block before using it */
Error_init(&eb);
/* create main thread (interrupts not enabled in main on BIOS) */
Task_Params_init(&taskParams);
taskParams.instance->name = "smain";
taskParams.arg0 = (UArg)argc;
taskParams.arg1 = (UArg)argv;
taskParams.stackSize = 0x700;
Task_create(smain, &taskParams, &eb);
if (Error_check(&eb)) {
System_abort((String)(LOGSTR(13)));
}
/* start scheduler, this never returns */
BIOS_start();
/* should never get here */
return(0);
}
/*
* ======== main ========
*/
int main()
{
/* initialize all device/board specific peripherals */
Board_init();
Task_Params taskParams;
System_printf("Startup\n");
System_flush();
/* initialize taskParams to the defaults */
Task_Params_init(&taskParams);
taskParams.priority = Task_numPriorities - 1;
taskParams.stackSize = 0x800;
/* Set the task name */
taskParams.instance->name = (xdc_String)"hello";
/* Create the task */
Task_create(hello_task, &taskParams, NULL);
/* does not return */
BIOS_start();
return (0); /* should never get here, but just in case ... */
}
Int main(Int argc, Char* argv[])
{
Error_Block eb;
Task_Params taskParams;
Log_print3(Diags_ENTRY,
"--> %s: (argc: %d, argv: 0x%x)", (IArg)FXNN, (IArg)argc, (IArg)argv);
/* must initialize the error block before using it */
Error_init(&eb);
/* initialize ipc layer */
Ipc_start();
/* create main thread (interrupts not enabled in main on BIOS) */
Task_Params_init(&taskParams);
taskParams.instance->name = "AppMain_main__P";
taskParams.arg0 = (UArg)argc;
taskParams.arg1 = (UArg)argv;
taskParams.stackSize = 0x4000;
Task_create(AppMain_main__P, &taskParams, &eb);
if (Error_check(&eb)) {
System_abort("main() failed to create application startup thread");
}
/* start scheduler, this never returns */
BIOS_start();
/* should never get here */
Log_print1(Diags_EXIT, "<-- %s: should never get here", (IArg)FXNN);
return(0);
}
/*
* ======== main ========
*/
Int main(Int argc, Char* argv[])
{
Error_Block eb;
Task_Params taskParams;
Log_print0(Diags_ENTRY, "--> main:");
/* must initialize the error block before using it */
Error_init(&eb);
/* create main thread (interrupts not enabled in main on BIOS) */
Task_Params_init(&taskParams);
taskParams.instance->name = "smain";
taskParams.stackSize = 0x1000;
Task_create(smain, &taskParams, &eb);
if (Error_check(&eb)) {
System_abort("main: failed to create application startup thread");
}
/* start scheduler, this never returns */
BIOS_start();
/* should never get here */
Log_print0(Diags_EXIT, "<-- main:");
return (0);
}
Int main(Int argc, Char* argv[])
{
Error_Block eb;
Task_Params taskParams;
Registry_Result result;
Log_print0(Diags_ENTRY, "--> main:");
/* must initialize the error block before using it */
Error_init(&eb);
/* create main thread (interrupts not enabled in main on BIOS) */
Task_Params_init(&taskParams);
taskParams.instance->name = "smain";
taskParams.stackSize = 0x1000;
Task_create(smain, &taskParams, &eb);
if (Error_check(&eb)) {
System_abort("main: failed to create application startup thread");
}
/* register with xdc.runtime to get a diags mask */
result = Registry_addModule(&Registry_CURDESC, MODULE_NAME);
Assert_isTrue(result == Registry_SUCCESS, (Assert_Id)NULL);
/* start scheduler, this never returns */
BIOS_start();
/* should never get here */
Log_print0(Diags_EXIT, "<-- main:");
return (0);
}
/*
* ======== main ========
*/
Int main(Int argc, Char* argv[])
{
Int status;
Task_Params taskParams;
/* initialize ipc layer */
do {
status = Ipc_start();
} while (status < 0);
/* create main thread (interrupts not enabled in main on BIOS) */
Task_Params_init(&taskParams);
taskParams.instance->name = "smain";
taskParams.arg0 = (UArg)argc;
taskParams.arg1 = (UArg)argv;
taskParams.stackSize = 0x4000;
Task_create(smain, &taskParams, NULL);
/* start scheduler, this never returns */
BIOS_start();
/* should never get here */
return(0);
}
/**
* /fn SetupUartTask
* /brief Setup UART tasks.
*
* Task has priority 15 and receives 1kB of stack.
*
* /return Always 0. In case of error the system halts.
*/
int SetupUartTask(void) {
Task_Params taskTransferParams;
Task_Handle taskTransfer;
Error_Block eb;
/* Enable and configure the peripherals used by the UART7 */
SysCtlPeripheralEnable(GPIO_PORTC_BASE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART7);
GPIOPinConfigure(GPIO_PC4_U7RX);
GPIOPinConfigure(GPIO_PC5_U7TX);
GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5);
/* Enable and configure the peripherals used by the UART6 */
SysCtlPeripheralEnable(GPIO_PORTP_BASE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART6);
GPIOPinConfigure(GPIO_PP0_U6RX);
GPIOPinConfigure(GPIO_PP1_U6TX);
GPIOPinTypeUART(GPIO_PORTP_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UART_init();
InitializeLedUserSwitch();
Error_init(&eb);
Task_Params_init(&taskTransferParams);
taskTransferParams.stackSize = 1024;
taskTransferParams.priority = 15;
taskTransfer = Task_create((Task_FuncPtr) TransferFunction,
&taskTransferParams, &eb);
if (taskTransfer == NULL) {
System_abort("UART task create failed");
}
return (0);
}
/*
* ======== main ========
*/
int main(void) {
Task_Handle taskHandle;
Task_Params taskParams;
Error_Block eb;
#ifdef TIVAWARE
/*
* This is a work-around for EMAC initialization issues found on
* the TM4C129 devices. The bug number is:
* SDOCM00107378: NDK examples for EK-TM4C1294XL do not work
*
* The following disables the flash pre-fetch. It is enable within the
* EMAC driver (in the EMACSnow_NIMUInit() function).
*/
UInt32 ui32FlashConf;
ui32FlashConf = HWREG(0x400FDFC8);
ui32FlashConf &= ~(0x00020000);
ui32FlashConf |= 0x00010000;
HWREG(0x400FDFC8) = ui32FlashConf;
#endif
/* Call board init functions */
Board_initGeneral();
Board_initGPIO();
Board_initEMAC();
/*
* CyaSSL library needs time() for validating certificates.
* USER STEP: Set up the current time in seconds below.
*/
MYTIME_init();
MYTIME_settime(1408053541);
System_printf("Starting the TCP Echo example\nSystem provider is set to "
"SysMin. Halt the target to view any SysMin contents in"
" ROV.\n");
/* SysMin will only print to the console when you call flush or exit */
System_flush();
/*
* Create the Task that farms out incoming TCP connections.
* arg0 will be the port that this task listens to.
*/
Task_Params_init(&taskParams);
Error_init(&eb);
taskParams.stackSize = 32768;
taskParams.priority = 1;
taskParams.arg0 = TCPPORT;
taskHandle = Task_create((Task_FuncPtr) tcpHandler, &taskParams, &eb);
if (taskHandle == NULL) {
System_printf("main: Failed to create tcpHandler Task\n");
}
/* Start BIOS */
BIOS_start();
return (0);
}
void start_ping_tasks()
{
Task_Params params;
/* Respond to ping tests from Linux side rpmsg sample drivers: */
Task_Params_init(¶ms);
params.instance->name = "copy0";
params.priority = 3;
params.arg0 = 50;
Task_create(copyTaskFxn, ¶ms, NULL);
Task_Params_init(¶ms);
params.instance->name = "copy1";
params.priority = 3;
params.arg0 = 51;
Task_create(copyTaskFxn, ¶ms, NULL);
}
/* ARGSUSED */
Void smain(UArg arg0, UArg arg1)
{
SemThread_Params semParams;
Task_Params taskParams;
Task_Handle tsk;
Int i;
Log_print0(Diags_ENTRY, "[+E] smain> Enter ");
SemThread_Params_init(&semParams);
done = SemThread_create(0, &semParams, NULL);
SemThread_Params_init(&semParams);
mutex = SemThread_create(1, &semParams, NULL);
if ((done == NULL) || (mutex == NULL)) {
Log_print0(Diags_USER7, "[+7] smain> SemThread creation failed");
System_abort("SemThread_create failed \n");
}
Task_Params_init(&taskParams);
/*
* Add the following line to have the stack allocated from the external
* heap:
* taskParams.stackHeap = (IHeap_Handle)EXTMEM_HEAP;
*/
taskParams.stackSize = 0x1000;
for (i = 0; i < NUMTASKS; i++) {
Task_Params_init(&taskParams);
taskParams.priority = attrsTable[i].priority;
taskParams.arg0 = i + 1; /* task id */
taskParams.arg1 = i; /* index into attrsTable */
tsk = Task_create((Task_FuncPtr)rmanTask, &taskParams, NULL);
if (tsk == NULL) {
Log_print1(Diags_USER7, "[+7] smain> Task_create of task %d failed",
(IArg)(i + 1));
System_abort("Task_create() failed\n");
}
}
for (i = 0; i < NUMTASKS; i++) {
SemThread_pend(done, SemThread_FOREVER, NULL);
}
SemThread_delete(&mutex);
SemThread_delete(&done);
Log_print0(Diags_USER4, "[+4] smain> TEST PASSED ");
Log_print0(Diags_EXIT, "[+X] smain> Exit ");
}
/*
* ======== main ========
*/
Int main()
{
Clock_Params clkParams;
Task_Params tskParams;
Mailbox_Params mbxParams;
Semaphore_Params semParams;
/* Create a one-shot Clock Instance with timeout = 5 system time units */
Clock_Params_init(&clkParams);
clkParams.startFlag = TRUE;
clk1 = Clock_create(clk0Fxn, 5, &clkParams, NULL);
/* Create an one-shot Clock Instance with timeout = 10 system time units */
Clock_Params_init(&clkParams);
clkParams.startFlag = TRUE;
clk2 = Clock_create(clk1Fxn, 10, &clkParams, NULL);
/* create an Event Instance */
evt = Event_create(NULL, NULL);
/* create a Semaphore Instance */
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_BINARY;
semParams.event = evt;
semParams.eventId = Event_Id_01;
sem = Semaphore_create(0, &semParams, NULL);
/* create a Mailbox Instance */
Mailbox_Params_init(&mbxParams);
mbxParams.readerEvent = evt;
mbxParams.readerEventId = Event_Id_02;
mbx = Mailbox_create(sizeof(MsgObj), 2, &mbxParams, NULL);
/* create a writer task */
Task_Params_init(&tskParams);
tskParams.priority = 1;
tskParams.arg0 = (UArg) mbx;
Task_create(writer, &tskParams, NULL);
/* create a reader task */
Task_create(reader, &tskParams, NULL);
BIOS_start(); /* does not return */
return(0);
}
void start_resmgr_task()
{
Task_Params params;
Task_Params_init(¶ms);
params.instance->name = "IpcResource";
params.priority = 3;
Task_create(IpcResourceTaskFxn, ¶ms, NULL);
}
/*
* ======== ThreadSupport_Instance_init ========
*/
Int ThreadSupport_Instance_init(ThreadSupport_Handle obj,
ThreadSupport_RunFxn fxn, const ThreadSupport_Params* params,
Error_Block* eb)
{
Task_Params tpars;
Semaphore_Handle bios6sem;
bios6sem = ThreadSupport_Instance_State_join_sem(obj);
Task_Params_init(&tpars);
tpars.arg0 = (UArg)obj;
if (params->stackSize != 0) {
tpars.stackSize = params->stackSize;
}
tpars.env = obj;
tpars.instance->name = params->instance->name;
if (params->osPriority != ThreadSupport_INVALID_OS_PRIORITY) {
tpars.priority = params->osPriority;
}
else {
if (params->priority == ThreadSupport_Priority_LOWEST) {
tpars.priority = ThreadSupport_lowestPriority;
}
else if (params->priority == ThreadSupport_Priority_BELOW_NORMAL) {
tpars.priority = ThreadSupport_belowNormalPriority;
}
else if (params->priority == ThreadSupport_Priority_NORMAL) {
tpars.priority = ThreadSupport_normalPriority;
}
else if (params->priority == ThreadSupport_Priority_ABOVE_NORMAL) {
tpars.priority = ThreadSupport_aboveNormalPriority;
}
else if (params->priority == ThreadSupport_Priority_HIGHEST) {
tpars.priority = ThreadSupport_highestPriority;
}
else {
Error_raise(eb, ThreadSupport_E_priority, params->priority, 0);
return (ThreadSupport_PRI_FAILURE);
}
}
obj->tls = params->tls;
obj->startFxn = fxn;
obj->startFxnArg = params->arg;
Semaphore_construct(Semaphore_struct(bios6sem), 0, NULL);
obj->task = Task_create(&ThreadSupport_runStub, &tpars, eb);
if (Error_check(eb)) {
return (ThreadSupport_TASK_FAILURE);
}
return (0);
}
int main(void)
{
/* Call board init functions. */
Board_initGeneral();
Board_initGPIO();
// Board_initI2C();
// Board_initSDSPI();
// Board_initSPI();
// Board_initUART();
// Board_initWatchdog();
Clock_Params clockParams;
Clock_Handle myClock;
Error_Block eb;
Task_Handle task0;
Task_Params taskParams;
Task_Params_init(&taskParams);
int j;
for(j=0; j<17; j++) {
buff1[j] = ' ';
buff2[j] = ' ';
}
Error_init(&eb);
Clock_Params_init(&clockParams);
clockParams.period = 100;
clockParams.startFlag = TRUE;
myClock = Clock_create(LCD_print, 10, &clockParams, &eb);
if(myClock == 0)
{
System_abort("F****n clock");
}
LCD_init();
task0 = Task_create(heartBeatFxn, &taskParams, &eb);
// sample_screen();F
/* Turn on user LED */
GPIO_write(Board_LED0, Board_LED_ON);
System_printf("Starting the example\nSystem provider is set to SysMin. "
"Halt the target to view any SysMin contents in ROV.\n");
//GPIO_write(4,1);
/* SysMin will only print to the console when you call flush or exit */
System_flush();
/* Start BIOS */
BIOS_start();
return (0);
}
static Void OffloadM3_createTask(UArg sem, UArg arg1)
{
Semaphore_Handle semHandle = (Semaphore_Handle)sem;
Task_Params params;
Int i;
while (1) {
Semaphore_pend(semHandle, BIOS_WAIT_FOREVER);
Mutex_enter();
if (!module.created) {
for (i = OFFLOAD_AC_IDX; i < OFFLOAD_MAX_IDX; i++) {
module.semaphores[i] = Semaphore_create(0, NULL, NULL);
}
Task_Params_init(¶ms);
params.instance->name = "workerTaskAC";
params.priority = xdc_runtime_knl_Thread_Priority_NORMAL;
params.arg0 = (UArg)module.semaphores[OFFLOAD_AC_IDX];
params.arg1 = (UArg)&interm3PayloadAC;
module.tasks[OFFLOAD_AC_IDX] = Task_create(OffloadM3_workerTask, ¶ms, NULL);
Task_Params_init(¶ms);
params.instance->name = "workerTaskVS";
params.priority = xdc_runtime_knl_Thread_Priority_NORMAL;
params.arg0 = (UArg)module.semaphores[OFFLOAD_VS_IDX];
params.arg1 = (UArg)&interm3PayloadVS;
module.tasks[OFFLOAD_VS_IDX] = Task_create(OffloadM3_workerTask, ¶ms, NULL);
Task_Params_init(¶ms);
/* Create a lower priority thread */
params.instance->name = "workerTaskMM";
params.priority = xdc_runtime_knl_Thread_Priority_BELOW_NORMAL;
params.arg0 = (UArg)module.semaphores[OFFLOAD_MM_IDX];
params.arg1 = (UArg)&interm3PayloadMM;
module.tasks[OFFLOAD_MM_IDX] = Task_create(OffloadM3_workerTask, ¶ms, NULL);
module.created = TRUE;
}
Mutex_leave();
}
}
void net_open_hook()
{
Task_Params taskParams;
Error_Block eb;
Error_init(&eb);
Task_Params_init(&taskParams);
taskParams.stackSize = TCPHANDLERSTACK;
taskParams.priority = 1;
Task_create((Task_FuncPtr)tcp_server, &taskParams, &eb);
}
/*
* ======== main ========
*/
Int main()
{
Task_Params taskParams;
Error_Block eb;
Memory_Stats stats;
Error_init(&eb);
/* Picking a stackSize such that the second Task_create() will fail */
Memory_getStats(Memory_defaultHeapInstance, &stats);
Task_Params_init(&taskParams);
taskParams.priority = 1;
taskParams.stackSize = (stats.totalFreeSize/2) + 64;
/*
* Create two tasks, The first one succeeds and the second one fails
* We catch the second failure in the Error_Block
*/
tsk1 = Task_create(task1, &taskParams, &eb);
if (Error_check(&eb)) {
/* Should not get here */
System_printf("First Task_create() failed\n");
BIOS_exit(0);
}
Error_init(&eb);
tsk2 = Task_create(task2, &taskParams, &eb);
if (Error_check(&eb)) {
/* Should get here */
System_printf("Second Task_create() failed\n");
}
BIOS_start(); /* does not return */
return(0);
}
/*
* ======== taskMstr ========
* Calls different taskts depending on which core we are working
*/
Void taskMstr(UArg a0, UArg a1){
Uint32 coreNum;
coreNum = CSL_chipReadReg(CSL_CHIP_DNUM);
Task_Params tskpr;
Task_Params_init(&tskpr);
/*
* no need to add semaphores to remove concurrency possibility
*/
if(coreNum == 0){
Task_create(task0, NULL, NULL);
}else if(coreNum == 1){
Task_create(task1, NULL, NULL);
}else if(coreNum == 2){
Task_create(task2, NULL, NULL);
}else{
Task_create(task3, NULL, NULL);
}
}
/*
* ======== main ========
*/
int main(int argc, char** argv)
{
/* Initialize the defaults and set the parameters. */
Task_Handle handle;
Task_Params taskParams;
Task_Params_init(&taskParams);
taskParams.stackSize = 65535;
handle = Task_create(runBenchmarks, &taskParams, NULL);
if (handle == NULL) {
System_printf("main: Failed to create new Task.\n");
}
BIOS_start();
}
/*
* ======== HdmiWa_Module_startup ========
*/
Int HdmiWa_Module_startup(Int phase)
{
/* This should be populated in the start/stop callback */
Task_Params params;
/* Configure the custom clock function pointer in IpcPower */
IpcPower_clockFxn = HdmiWa_tick;
Task_Params_init(¶ms);
params.instance->name = "HdmiWa_taskFxn";
params.priority = 1;
Task_create(HdmiWa_taskFxn, ¶ms, NULL);
return Startup_DONE;
}
Int main(Int argc, char* argv[])
{
Task_Params params;
System_printf("%s starting..\n", MultiProc_getName(MultiProc_self()));
/* Create a Task to respond to the ping from the Host side */
Task_Params_init(¶ms);
params.instance->name = "ping";
params.arg0 = 51;
Task_create(pingTaskFxn, ¶ms, NULL);
BIOS_start();
return (0);
}
void Create_uartHandler() {
// Create UART task (RS-485)
Task_Handle UART_taskHandle;
Task_Params UART_taskParams;
Error_Block UART_eb;
Task_Params_init(&UART_taskParams);
Error_init(&UART_eb);
UART_taskParams.stackSize = 2048;
UART_taskParams.priority = 1;
UART_taskParams.arg0 = 1000;
UART_taskHandle = Task_create((Task_FuncPtr) uartHandler, &UART_taskParams,
&UART_eb);
if (UART_taskHandle == NULL) {
System_printf("main: Failed to create uartHandler Task\n");
}
}
