/*! * ======== 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); }
/* 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() { /* 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 ... */ }
/* * ======== 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(); }
/* * ======== 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"); } }
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); }
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 ======== */ 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); }
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); }
/** * /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); }
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(); }
/* * ======== 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); }
/* * 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_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); }
/* * ======== 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); }
/* * ======== 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); }
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(); } }
/********************************************************************* * @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); }
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); }
/********************************************************************* * @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); }
/********************************************************************* * @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); }
/** * @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); }