Exemplo n.º 1
0
/*!
 * ======== 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);
}
Exemplo n.º 2
0
/* 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 ");
}
Exemplo n.º 3
0
Arquivo: main.cpp Projeto: energia/emt
/*
 *  ======== 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 ... */
}
Exemplo n.º 4
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();
}
Exemplo n.º 5
0
/*
 *  ======== main ========
 */
int main(void)
{
    Task_Params taskParams;

    /* Call board init functions */
    Board_initGeneral();
    Board_initGPIO();
    Board_initSDSPI();

    /* Construct file copy Task thread */
    Task_Params_init(&taskParams);
    taskParams.stackSize = TASKSTACKSIZE;
    taskParams.stack = &task0Stack;
    Task_construct(&task0Struct, (Task_FuncPtr)taskFxn, &taskParams, NULL);

    /* Turn on user LED */
    GPIO_write(Board_LED0, Board_LED_ON);

    System_printf("Starting the FatSD Raw example\n");

    /* Start BIOS */
    BIOS_start();

    return (0);
}
/*
 *  ======== 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");
    }
}
Exemplo n.º 7
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);
}
Exemplo n.º 8
0
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();
}
Exemplo n.º 9
0
int8_t BtStack_start(void)
{
	if (rxTask != NULL)
	{
		// service already started
		return -1;
	}

	// creating the task
	Task_Params params;
	Task_Params_init(&params);
	params.instance->name = "btStack::rx";
	params.priority = rxPriority;
	params.stackSize = rxStackSize;

	Error_Block eb;
	Error_init(&eb);

	rxTask = Task_create((Task_FuncPtr) rxFxn, &params, &eb);
	if (rxTask == NULL)
	{
		return -2;
	}
	else
	{
		hasStart = TRUE;
		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);
}
Exemplo n.º 11
0
int main(void)
{
    Task_Params taskParams;

    /* Call board init functions */
    Board_initGeneral();
    memoryInit(spiHandle, 6250);
    // Board_initWatchdog();

    /* Construct heartBeat Task  thread */
    Task_Params_init(&taskParams);
    taskParams.arg0 = 1000000 / Clock_tickPeriod;
    taskParams.stackSize = TASKSTACKSIZE;
    taskParams.stack = &task0Stack;
    Task_construct(&task0Struct, (Task_FuncPtr)heartBeatFxn, &taskParams, NULL);

    /* Open LED pins */
    ledPinHandle = PIN_open(&ledPinState, ledPinTable);
    if(!ledPinHandle) {
        System_abort("Error initializing board LED pins\n");
    }

    //IOCPortConfigureSet(PIN_SPI_MOSI, PORTID, PIN-CONFIG); // oklart om och hur denna funkar.
    //IOCPortConfigureSet(DIOn, PORTID, PIN-CONFIG);
    //PIN_setOutputValue(ledPinHandle, Board_LED1, 1);

    /* Start BIOS */
    BIOS_start();

    return (0);
}
Exemplo n.º 12
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);
}
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);
}
Exemplo n.º 14
0
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();
}
Exemplo n.º 15
0
/*
 *  ======== main ========
 */
int main(void)
{
    Task_Params taskParams;

    /* Call board init functions */
    Board_initGeneral();
    Board_initGPIO();
    // Board_initI2C();
    // Board_initSDSPI();
    // Board_initSPI();
    // Board_initUART();
    // Board_initUSB(Board_USBDEVICE);
    // Board_initWatchdog();
    // Board_initWiFi();

    /* Construct heartBeat Task  thread */
    Task_Params_init(&taskParams);
    taskParams.arg0 = 1000;
    taskParams.stackSize = TASKSTACKSIZE;
    taskParams.stack = &task0Stack;
    Task_construct(&task0Struct, (Task_FuncPtr)heartBeatFxn, &taskParams, NULL);

    /* 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");
    /* SysMin will only print to the console when you call flush or exit */
    System_flush();

    /* Start BIOS */
    BIOS_start();

    return (0);
}
Exemplo n.º 16
0
/*
 *  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);
}
Exemplo n.º 17
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);
}
Exemplo n.º 18
0
/*
 *  ======== main ========
 */
int main(void)
{
    /* Call board init functions */
    Board_initGeneral();
    Board_initGPIO();
    Board_initUART();

    /* Construct BIOS objects */
    Task_Params taskParams;

    Task_Params_init(&taskParams);
    taskParams.stackSize = TASKSTACKSIZE;
    taskParams.stack = &task0Stack;
    taskParams.instance->name = "echo";
    Task_construct(&task0Struct, (Task_FuncPtr)echoFxn, &taskParams, NULL);

    /* Turn on user LED */
    GPIO_write(Board_LED0, Board_LED_ON);


    /* Start BIOS */
    BIOS_start();

    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);
}
Exemplo n.º 20
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);
}
Exemplo n.º 21
0
void start_ping_tasks()
{
    Task_Params params;

    /* Respond to ping tests from Linux side rpmsg sample drivers: */
    Task_Params_init(&params);
    params.instance->name = "copy0";
    params.priority = 3;
    params.arg0 = 50;
    Task_create(copyTaskFxn, &params, NULL);

    Task_Params_init(&params);
    params.instance->name = "copy1";
    params.priority = 3;
    params.arg0 = 51;
    Task_create(copyTaskFxn, &params, NULL);
}
Exemplo n.º 22
0
void start_resmgr_task()
{
    Task_Params params;

    Task_Params_init(&params);
    params.instance->name = "IpcResource";
    params.priority = 3;
    Task_create(IpcResourceTaskFxn, &params, NULL);
}
Exemplo n.º 23
0
/*
 *  ======== 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);
}
Exemplo n.º 24
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);
}
Exemplo n.º 25
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(&params);
            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, &params, NULL);

            Task_Params_init(&params);
            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, &params, NULL);

            Task_Params_init(&params);
            /* 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, &params, NULL);

            module.created = TRUE;
        }
        Mutex_leave();
    }
}
Exemplo n.º 26
0
/*********************************************************************
 * @fn      SensorTagBar_createTask
 *
 * @brief   Task creation function for barometer sensor
 *
 * @param   none
 *
 * @return  none
 */
void SensorTagBar_createTask(void)
{
  Task_Params taskParames;

  // Create the task for the state machine
  Task_Params_init(&taskParames);
  taskParames.stack = sensorTaskStack;
  taskParames.stackSize = SENSOR_TASK_STACK_SIZE;
  taskParames.priority = SENSOR_TASK_PRIORITY;

  Task_construct(&sensorTask, sensorTaskFxn, &taskParames, NULL);
}
Exemplo n.º 27
0
Arquivo: adc.c Projeto: wzyy2/ECG-BLE
void Adc_createTask(void)
{
  Task_Params taskParams;
  
  // Configure task
  Task_Params_init(&taskParams);
  taskParams.stack = Adc_taskStack;
  taskParams.stackSize = 512;
  taskParams.priority = 3;
  
  Task_construct(&Adc_task, Adc_entry, &taskParams, NULL);
}
Exemplo n.º 28
0
/*********************************************************************
 * @fn      simpleTopology_createTask
 *
 * @brief   Task creation function for the Simple BLE Peripheral.
 *
 * @param   None.
 *
 * @return  None.
 */
void SimpleTopology_createTask(void)
{
  Task_Params taskParams;

  // Configure task
  Task_Params_init(&taskParams);
  taskParams.stack = sbmTaskStack;
  taskParams.stackSize = SBT_TASK_STACK_SIZE;
  taskParams.priority = SBT_TASK_PRIORITY;

  Task_construct(&sbmTask, simpleTopology_taskFxn, &taskParams, NULL);
}
Exemplo n.º 29
0
/*********************************************************************
 * @fn      SimpleBLEBroadcaster_createTask
 *
 * @brief   Task creation function for the Simple BLE Broadcaster.
 *
 * @param   none
 *
 * @return  none
 */
void SimpleBLEBroadcaster_createTask(void)
{
  Task_Params taskParams;
    
  // Configure task
  Task_Params_init(&taskParams);
  taskParams.stack = sbbTaskStack;
  taskParams.stackSize = SBB_TASK_STACK_SIZE;
  taskParams.priority = SBB_TASK_PRIORITY;
  
  Task_construct(&sbbTask, SimpleBLEBroadcaster_taskFxn, &taskParams, NULL);
}
Exemplo n.º 30
0
/**
 * @brief   Task creation function for the GAP Observer Role.
 *
 * @param   none
 *
 * @return  none
 */
void GAPObserverRole_createTask(void)
{
  Task_Params taskParams;

  // Configure task
  Task_Params_init(&taskParams);
  taskParams.stack = gapObserverRoleTaskStack;
  taskParams.stackSize = GAPOBSERVERROLE_TASK_STACK_SIZE;
  taskParams.priority = GAPOBSERVERROLE_TASK_PRIORITY;
  
  Task_construct(&gapObserverRoleTask, gapObserverRole_taskFxn, &taskParams, NULL);
}