自学教程：C++ Error_init函数代码示例

/* Function to allocate memory from the SyslinkMemMgr */Ptr SyslinkMemMgr_SharedMemory_alloc(SyslinkMemMgr_SharedMemory_Object *obj,        SyslinkMemMgr_AllocParams *allocParams){    Ptr   buf = NULL;    Error_Block eb;    Error_init (&eb);    if (obj != NULL) {        buf = Memory_alloc(obj->heapHandle, allocParams->size,                allocParams->align, &eb);    }    return (buf);}

void Event::begin(){    Error_Block eb;    Error_init(&eb);        Event_Params params;    Event_Params_init(&params);        EventHandle = Event_create(&params, &eb);        if (EventHandle == NULL)    {        System_abort("Event create failed");    }}

/*! *  ======== InterruptArp32_intRegister ======== */Void InterruptArp32_intRegister(UInt16 remoteProcId,                                 IInterrupt_IntInfo *intInfo,                                 Fxn func, UArg arg){    UInt        key;    Hwi_Params  hwiAttrs;    Error_Block eb;    InterruptArp32_FxnTable *table;    Assert_isTrue(remoteProcId < ti_sdo_utils_MultiProc_numProcessors,             ti_sdo_ipc_Ipc_A_internal);    /* Assert that our MultiProc id is set correctly */    Assert_isTrue((InterruptArp32_arp32ProcId == MultiProc_self()),                    ti_sdo_ipc_Ipc_A_internal);    /* init error block */    Error_init(&eb);        /* Disable global interrupts */    key = Hwi_disable();    table = &(InterruptArp32_module->fxnTable);    table->func = func;    table->arg  = arg;    InterruptArp32_intClear(remoteProcId, intInfo);        /* Make sure the interrupt only gets plugged once */    InterruptArp32_module->numPlugged++;    if (InterruptArp32_module->numPlugged == 1) {         /* Register interrupt to remote processor */        Hwi_Params_init(&hwiAttrs);        hwiAttrs.arg = arg;        hwiAttrs.vectorNum = intInfo->intVectorId;        Hwi_create(ARP32INT,                  (Hwi_FuncPtr)InterruptArp32_intShmStub,                   &hwiAttrs,                   &eb);    }    /* enable the mailbox and Hwi */    InterruptArp32_intEnable(remoteProcId, intInfo);        /* Restore global interrupts */    Hwi_restore(key);}

/*! *  ======== NotifySetup_attach ======== *  Initialize interrupt */     Int NotifySetup_attach(UInt16 remoteProcId, Ptr sharedAddr){    NotifyDriverShm_Params notifyShmParams;    NotifyDriverShm_Handle shmDrvHandle;    ti_sdo_ipc_Notify_Handle notifyHandle;    Int status = Notify_S_SUCCESS;    Error_Block eb;        Error_init(&eb);        NotifyDriverShm_Params_init(&notifyShmParams);    notifyShmParams.sharedAddr = sharedAddr;    notifyShmParams.remoteProcId  = remoteProcId;        /* Set the intVectorId if on the DSP */    if ((MultiProc_self() == NotifySetup_dsp0ProcId) ||        (MultiProc_self() == NotifySetup_dsp1ProcId)) {            notifyShmParams.intVectorId = NotifySetup_dspIntVectId;    }    /* Set the intVectorId if on the EVE */    if ((MultiProc_self() == NotifySetup_eve0ProcId) ||        (MultiProc_self() == NotifySetup_eve1ProcId) ||        (MultiProc_self() == NotifySetup_eve2ProcId) ||        (MultiProc_self() == NotifySetup_eve3ProcId)) {        if (PROCID(remoteProcId) < 4) {            notifyShmParams.intVectorId = NotifySetup_eveIntVectId_INTC1;        }        else {            notifyShmParams.intVectorId = NotifySetup_eveIntVectId_INTC0;        }    }        shmDrvHandle = NotifyDriverShm_create(&notifyShmParams, &eb);    if (shmDrvHandle == NULL) {        return (Notify_E_FAIL);    }        notifyHandle = ti_sdo_ipc_Notify_create(            NotifyDriverShm_Handle_upCast(shmDrvHandle), remoteProcId, 0,             NULL, &eb);    if (notifyHandle == NULL) {        NotifyDriverShm_delete(&shmDrvHandle);        status = Notify_E_FAIL;    }    return (status);}

/* *  ======== Power_registerConstraint ======== *  Register an operational constraint with Power. * */Power_Status Power_registerConstraint(Power_Constraint type, UArg value,    Power_ConstraintHandle *handle){    Power_Status status = Power_SOK;    Power_ConstraintObj * pConstraint;    Error_Block eb;    /* check for NULL handle pointer */    if (handle == NULL) {        status = Power_EINVALIDPOINTER;    }    /* else, check for invalid constraint type */    else if ((type < Power_DISALLOWED_CPU_SETPOINT_MASK) ||             (type > Power_DISALLOWEDSLEEPSTATE_MASK)) {        status = Power_EINVALIDVALUE;    }    /* else, allocate a constraint object */    else {        Error_init(&eb);        pConstraint = Memory_calloc(Power_Object_heap(),             sizeof(Power_ConstraintObj), 0, &eb);        if ((pConstraint == NULL) || Error_check(&eb)) {            status = Power_EFAIL;        }        /* fill in and enqueue the constraint, update aggregate constraints */        else {            /* fill in constraint object elements */            pConstraint->type = type;            pConstraint->value = value;            /* place constraint object on the constraints queue */            Queue_put(Power_Module_State_constraintsQ(),                 (Queue_Elem*) pConstraint);            /* update aggregated constraints with the new constraint */            Power_updateConstraints(type, value);            /* set out parameters */            *handle = (UArg *) pConstraint;        }    }    return (status);}

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");	}}

/* *  ======== Power_registerNotify ======== *  Register a function to be called on a specific power event. * */Power_Status Power_registerNotify(Power_Event eventType, UInt eventMask,    Fxn notifyFxn, UArg clientArg, Power_NotifyHandle * notifyHandle,    Fxn *delayedCompletionFxn){    Power_NotifyObj * pNotify;    Queue_Handle notifyQ;    Error_Block eb;    /* check for out of range event type */    if ((eventType < 0) || (eventType >= Power_INVALIDEVENT)) {        return (Power_EINVALIDEVENT);    }    /* check for NULL pointers for notifyFxn and out params */    if ((notifyFxn == NULL) || (notifyHandle == NULL) ||       (delayedCompletionFxn == NULL)) {        return (Power_EINVALIDPOINTER);    }    /* allocate a notification object */    Error_init(&eb);    pNotify = Memory_calloc(Power_Object_heap(), sizeof(Power_NotifyObj), 0,         &eb);    if ((pNotify == NULL) || Error_check(&eb)) {        return (Power_EFAIL);    }    /* fill in notify object elements */    pNotify->eventType = eventType;    pNotify->notifyFxn = notifyFxn;    pNotify->clientArg = clientArg;    pNotify->eventMask = eventMask;    /* determine the appropriate notification queue */    notifyQ = (Queue_Handle)((UInt8 *)(Power_module->notifyQ) +                (UInt)(eventType * (2 * sizeof(Ptr))));    /* place notify object on appropriate event queue */    Queue_put(notifyQ, (Queue_Elem*) pNotify);    /* set out parameters */    *notifyHandle = pNotify;    *delayedCompletionFxn =         (Fxn) ti_sysbios_family_c674_Power_delayCompletionFxns[eventType];    return(Power_SOK);}

Int RcmClient_create(String server, const RcmClient_Params *params,        RcmClient_Handle *handle){    RcmClient_Object *obj;    Error_Block eb;    Int status = RcmClient_S_SUCCESS;    Log_print1(Diags_ENTRY, "--> %s: ()", (IArg)FXNN);    /* initialize the error block */    Error_init(&eb);    *handle = (RcmClient_Handle)NULL;    /* TODO: add check that params was initialized correctly */    /* allocate the object */    obj = (RcmClient_Handle)xdc_runtime_Memory_calloc(RcmClient_Module_heap(),        sizeof(RcmClient_Object), sizeof(Int), &eb);    if (NULL == obj) {        Log_error2(FXNN": out of memory: heap=0x%x, size=%u",            (IArg)RcmClient_Module_heap(), sizeof(RcmClient_Object));        status = RcmClient_E_NOMEMORY;        goto leave;    }    Log_print1(Diags_LIFECYCLE, FXNN": instance create: 0x%x", (IArg)obj);    /* object-specific initialization */    status = RcmClient_Instance_init(obj, server, params);    if (status < 0) {        RcmClient_Instance_finalize(obj);        xdc_runtime_Memory_free(RcmClient_Module_heap(),            (Ptr)obj, sizeof(RcmClient_Object));        goto leave;    }    /* success, return opaque pointer */    *handle = (RcmClient_Handle)obj;leave:    Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);    return(status);}

//void SWItrigger::begin(uint8_t trigger, void (*functionSWItrigger)(uint8_t))void SWItrigger::begin(uint8_t trigger, void (*functionSWItrigger)()){    Error_Block eb;    Error_init(&eb);        Swi_Params swiParams;    Swi_Params_init(&swiParams);    swiParams.trigger = trigger;    //    SWItriggerHandle = Swi_create((Swi_FuncPtr)functionSWItrigger(Swi_getTrigger()), &swiParams, &eb);    SWItriggerHandle = Swi_create((Swi_FuncPtr)functionSWItrigger, &swiParams, &eb);    if (SWItriggerHandle == NULL)    {        System_abort("SWItrigger create failed");    }}

/* *  ======== main ======== */Int main(){     Task_Handle task;    Error_Block eb;    System_printf("enter main()/n");    Error_init(&eb);    task = Task_create(taskMstr, NULL, &eb);    if (task == NULL) {        System_printf("Task_create() failed!/n");        BIOS_exit(0);    }    BIOS_start();    /* does not return */    return(0);}

/** * /brief create semaphore object * * Creates a counting semaphore for inter-thread synchronization. * The initial semaphore count is specified as an input parameter. * * /param[in] p_sem_handle      Handle to semaphore control block * /param[in] p_name            Name of the semaphore - UNUSED in SYS/BIOS * /param[in] count             Initial count of the semaphore * * /return   e_SUCCESS on success, e_FAILURE on error * * /sa OS_semaphore_delete, OS_semaphore_put, OS_semaphore_get * /note * * /warning */e_ret_status OS_semaphore_create(handle p_handle,                                 const void *const p_name,     //UNUSED                                 uInt16 count){    Semaphore_Handle sem_handle = NULL;    Error_Block eb;    Error_init(&eb);    sem_handle = Semaphore_create(count, NULL, &eb);    if (NULL == sem_handle) {        return e_FAILURE;    }    *(Semaphore_Handle *)p_handle = sem_handle;    return e_SUCCESS;}

/******************************************************************************* Function name:  Task_Init1     **** Descriptions: **     			   Create a task in a non-running state    ** parameters:     Task *pThis, Task name, Task function, Task Fn Arg, Stack Size, 				 Task Priority.** Returned value: None   **** Dependencies/Limitations/Side Effects/Design Notes:**		Task is just created, and it will not run until Task_Start**                ******************************************************************************/BOOL Task_Init1(Task *pThis, String sName, pfnTask pfn, VOID *pArg, TaskStack eStacksize, TaskPri ePriority  ){	Error_Block eb;	//pThis->tskattrs = TSK_ATTRS;	 Task_Params_init(&(pThis->tskattrs));	 Error_init(&eb);	//pThis->tskattrs.stacksize = eStacksize;	pThis->tskattrs.stackSize= eStacksize;	//Setting of Task name	if (sName != NULL)	{		memcpy(pThis->Name, sName, TASK_NAME_SIZE);		//pThis->tskattrs.name = (String )&pThis->Name[0];		pThis->tskattrs.instance->name = (String )&pThis->Name[0];	}	else	{		//pThis->tskattrs.name = "DUMMY";		pThis->tskattrs.instance->name ="DUMMY";	}	//Setting of Task priority	pThis->tskattrs.priority = STE_TASK_SUSPEND; // Suspend the priority.	pThis->hPriority = ePriority;	//Setting argument	//pThis->tskattrs.arg0 =*(xdc_UArg*)pArg;	pThis->tskattrs.arg0 =(xdc_UArg)pArg;		//pThis->Handle = TSK_create((Fxn)pfn, &pThis->tskattrs, pArg);	pThis->Handle = Task_create((Task_FuncPtr)pfn, &pThis->tskattrs,&eb);    if (pThis->Handle == NULL)    {			printf("TASK: Failed create thread");			return FALSE;            ///SYS_abort("Failed create thread");			//Raise an exception.    }	return TRUE;}

/*! *  ======== InterruptDsp_intRegister ========  */Void InterruptDsp_intRegister(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo,                              Fxn func, UArg arg){    UInt        key;    Hwi_Params  hwiAttrs;    Error_Block eb;    InterruptDsp_FxnTable *table;           Assert_isTrue(intInfo->intVectorId <= 15, ti_sdo_ipc_Ipc_A_internal);    /* init error block */    Error_init(&eb);    /* Disable global interrupts */    key = Hwi_disable();    table = &(InterruptDsp_module->fxnTable);    table->func = func;    table->arg  = arg;        InterruptDsp_intClear(remoteProcId, intInfo);    /* Make sure the interrupt only gets plugged once */    InterruptDsp_module->numPlugged++;    if (InterruptDsp_module->numPlugged == 1) {         /* Register interrupt to remote processor */        Hwi_Params_init(&hwiAttrs);        hwiAttrs.arg = arg;        hwiAttrs.eventId = 90;        Hwi_create(intInfo->intVectorId,                   (Hwi_FuncPtr)InterruptDsp_intShmStub,                   &hwiAttrs,                   &eb);                /* enable the interrupt vector */        Hwi_enableInterrupt(intInfo->intVectorId);    }        /* Enable the mailbox interrupt to the DSP */    InterruptDsp_intEnable(remoteProcId, intInfo);        /* Restore global interrupts */    Hwi_restore(key);}

    int wc_InitMutex(wolfSSL_Mutex* m)    {        Semaphore_Params params;        Error_Block eb;        Error_init(&eb);        Semaphore_Params_init(&params);        params.mode = Semaphore_Mode_BINARY;        *m = Semaphore_create(1, &params, &eb);        if (Error_check(&eb)) {            Error_raise(&eb, Error_E_generic, "Failed to Create the semaphore.",                NULL);            return BAD_MUTEX_E;        }        else            return 0;    }

MBX_Handle MBX_create(Uns size, Uns length, MBX_Attrs *attrs){    Mailbox_Params params;    Error_Block eb;    if (attrs == NULL) {        attrs = &MBX_ATTRS;    }    Mailbox_Params_init(&params);    params.instance->name = attrs->name;    params.heap = MEM_getHandle(attrs->segid);    Error_init(&eb);    return ((MBX_Handle)Mailbox_create(size, length, &params, &eb));}

/* *  ======== ListMP_openByAddr ======== */Int ListMP_openByAddr(Ptr sharedAddr, ListMP_Handle *handlePtr){    ti_sdo_ipc_ListMP_Params params;    ti_sdo_ipc_ListMP_Attrs *attrs;    Error_Block eb;    Int status;    UInt16 id;        Error_init(&eb);        ti_sdo_ipc_ListMP_Params_init(&params);        /* Tell Instance_init() that we're opening */    params.openFlag = TRUE;        attrs = (ti_sdo_ipc_ListMP_Attrs *)sharedAddr;    params.sharedAddr = sharedAddr;    id = SharedRegion_getId(sharedAddr);        if (SharedRegion_isCacheEnabled(id)) {        Cache_inv(attrs, sizeof(ti_sdo_ipc_ListMP_Attrs), Cache_Type_ALL, TRUE);    }        if (attrs->status != ti_sdo_ipc_ListMP_CREATED) {        *handlePtr = NULL;        status = ListMP_E_NOTFOUND;    }    else {        /* Create the object */        *handlePtr = (ListMP_Handle)ti_sdo_ipc_ListMP_create(&params, &eb);        if (*handlePtr == NULL) {            status = ListMP_E_FAIL;        }        else {            status = ListMP_S_SUCCESS;        }    }    if (SharedRegion_isCacheEnabled(id)) {        Cache_inv(attrs, sizeof(ti_sdo_ipc_ListMP_Attrs), Cache_Type_ALL, TRUE);    }    return (status);}

/* Function to create a SyslinkMemMgr instance */SyslinkMemMgr_TilerMemory_Handle SyslinkMemMgr_TilerMemory_create(Ptr params){    Error_Block eb;    Error_init (&eb);    SyslinkMemMgr_TilerMemory_Object * obj = NULL;    SyslinkMemMgr_TilerMemory_Params *instParams =            (SyslinkMemMgr_TilerMemory_Params *)params;    /* Allocate Memory for the object */    obj = (SyslinkMemMgr_TilerMemory_Object *)Memory_alloc(NULL,            sizeof(SyslinkMemMgr_TilerMemory_Object), 0, &eb);    if (obj != NULL) {        obj->heapHandle = instParams->heapHandle;    }    return (obj);}

/** * /fn InitializeLedUserSwitch * /brief Initialize led D1 und USR SW1. * /return void. */static void InitializeLedUserSwitch() {	uint32_t strength;	uint32_t pinType;	Hwi_Params buttonHWIParams;	Hwi_Handle buttonHwi;	Error_Block eb;	// enable port N	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);	// LED2	GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);	/* set pin gpio port to output */	GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);	/*configure pad as standard pin with default output current*/	GPIOPadConfigGet(GPIO_PORTN_BASE, GPIO_PIN_1, &strength, &pinType);	GPIOPadConfigSet(GPIO_PORTN_BASE, GPIO_PIN_1, strength, GPIO_PIN_TYPE_STD);	/* turn off led 1 */	GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, 0);	/* configure switch 1 with pull up as input on GPIO_PIN_0 as pull-up pin */	GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_0);	GPIOPadConfigGet(GPIO_PORTJ_BASE, GPIO_PIN_0, &strength, &pinType);	GPIOPadConfigSet(GPIO_PORTJ_BASE, GPIO_PIN_0, strength,	GPIO_PIN_TYPE_STD_WPU);	Error_init(&eb);	Hwi_Params_init(&buttonHWIParams);	buttonHWIParams.arg = 0;	buttonHWIParams.enableInt = false;	buttonHwi = Hwi_create(INT_GPIOJ_TM4C129, ButtonFunction, &buttonHWIParams,			&eb);	if (buttonHwi == NULL) {		System_abort("Button Hardware interrupt create failed.");	}	Hwi_enableInterrupt(INT_GPIOJ_TM4C129);	GPIOIntEnable(GPIO_PORTJ_BASE, GPIO_INT_PIN_0);}

/** * /brief creates a mutex for inter-thread mutual exclusion for resource protection * * * *  /param[in] p_handle     Handle to a mutex control block *  /param[in] p_name       Name of mutex * * /return   e_SUCCESS on success, e_FAILURE on error * * /sa OS_mutex_delete, OS_mutex_lock, OS_mutex_unlock * /note * * /warning */e_ret_status OS_mutex_create(handle p_handle, const void *const p_name){    GateMutex_Params gateParams;    GateMutex_Handle mtx_handle = {0};    Error_Block eb;    GateMutex_Params_init(&gateParams);    Error_init(&eb);    gateParams.instance->name = "Default_Name";    mtx_handle = GateMutex_create(&gateParams, &eb);    if (NULL == mtx_handle) {        return e_FAILURE;    }    *(GateMutex_Handle *)p_handle = mtx_handle;    return e_SUCCESS;}

/******************************************************************************* Function name:  Task_Init      **** Descriptions: **     			   Create a task in a non-running state    ** parameters:     Task *pThis, Task name, Task function, Task Fn Arg, Stack Size, 				 Task Priority.** Returned value: None   **** Dependencies/Limitations/Side Effects/Design Notes:**		Task is just created, and it will not run until Task_Start**                ******************************************************************************/BOOL Task_Init(Task *pThis, String sName, pfnTask pfn, VOID *pArg){	//pThis->tskattrs = TSK_ATTRS;	Error_Block eb;	 Task_Params_init(&(pThis->tskattrs));	 Error_init(&eb);	//Setting of Task name	if (sName != NULL)	{		memcpy(pThis->Name, sName, TASK_NAME_SIZE);		//pThis->tskattrs.name = (String )&pThis->Name[0];		pThis->tskattrs.instance->name = (String )&pThis->Name[0];	}	else	{		//pThis->tskattrs.name = "DUMMY";		pThis->tskattrs.instance->name ="DUMMY";	}	//Setting of Task priority	pThis->tskattrs.priority = STE_TASK_SUSPEND; // Suspend the priority.	pThis->hPriority = STE_TASK_DEFAULT_PRI;//	printf("task stacksize %d/n",pThis->tskattrs.stacksize);	pThis->tskattrs.stackSize= 4*1024;	//Setting argument	//	pThis->tskattrs.arg0 =*(xdc_UArg*)pArg;	pThis->tskattrs.arg0 =(xdc_UArg)pArg;		//pThis->Handle = TSK_create((Fxn)pfn, &pThis->tskattrs, pArg);	pThis->Handle = Task_create((Task_FuncPtr)pfn, &pThis->tskattrs,&eb);    if (pThis->Handle == NULL)    {			printf("TASK: Failed create thread");			return FALSE;    }	return TRUE;}

/** * /brief create and run a new thread * * creates an application thread that starts execution at the specified task entry function. * The stack and priority, are among the attributes specified by the input parameters. * In addition, the initial execution state of the thread is set to start running immediately after the thead is created * *  /param[in] p_handle     Handle to a thread control block *  /param[in] p_params     Thread params - Memory to be freed by caller *                              stackSize = Size of stack *                              priority = Task's priority (Order specific to OS) *                              p_entry_function = Task's entry function * * /return   e_SUCCESS on success, e_FAILURE on error * * /sa OS_thread_delete, OS_thread_terminate, OS_thread_sleep * /note * * /warning */e_ret_status OS_thread_create(handle p_handle,                              s_thread_params *p_params){    Task_Handle tsk_handle = NULL;    Task_Params taskParams;    Error_Block eb;    Error_init(&eb);    Task_Params_init(&taskParams);    taskParams.stackSize = p_params->stack_size;    taskParams.priority = p_params->priority;    tsk_handle = Task_create(p_params->p_entry_function, &taskParams, &eb);    if (NULL == tsk_handle) {        return e_FAILURE;    }    *(Task_Handle *) p_handle = tsk_handle;    return e_SUCCESS;}

/* *  ======== MessageQ_create ======== */MessageQ_Handle MessageQ_create(String name, const MessageQ_Params *params){    ti_sdo_ipc_MessageQ_Handle handle;    ti_sdo_ipc_MessageQ_Params prms;    Error_Block eb;    Error_init(&eb);    if (params != NULL) {        ti_sdo_ipc_MessageQ_Params_init(&prms);                prms.synchronizer = params->synchronizer;        handle = ti_sdo_ipc_MessageQ_create(name, &prms, &eb);    }    else {        handle = ti_sdo_ipc_MessageQ_create(name, NULL, &eb);    }    return ((MessageQ_Handle)handle);}

/* *  ======== GIO_addDevice ======== */Int GIO_addDevice(String name, Ptr fxns, GIO_InitFxn initFxn, Int devid, Ptr deviceParams){    DEV_Handle device;    DEV_Params params;    Error_Block eb;    Error_init(&eb);    DEV_Params_init(&params);    params.deviceParams = deviceParams;    params.initFxn = initFxn;    params.devid = devid;    device = DEV_create(name, fxns, &params, &eb);    if (device != NULL) {         return (IOM_COMPLETED);    }    else {        return (IOM_EBADIO);    }}

/** * usage: this method creates the UART task, interacting with the queue, * 		  which is filled in the i2c_method * @method setup_UART_Task * @author: patrik.szabo * @param *none* * @return 0, if everything succeeded */int setup_UART_Task(void) {	Task_Params taskUARTParams;	Task_Handle taskUART;	Error_Block eb;	Error_init(&eb);	Task_Params_init(&taskUARTParams);	taskUARTParams.stackSize = 1024; // stack in bytes	taskUARTParams.priority = 14; // 15 is default 16 is highest priority -> see RTOS configuration	taskUART = Task_create((Task_FuncPtr) uart_method, &taskUARTParams, &eb);	if (taskUART == NULL) {		System_abort("TaskUART create failed");	}	uartQueue = Queue_create(NULL, NULL);	// TODO: this should be in external module	externalModuleQueue = Queue_create(NULL, NULL);	return (0);}

void Clock::begin(void (*ClockFunction)(void), uint32_t ClockTimeOut_ms, uint32_t ClockPeriod_ms){    Error_Block eb;    Error_init(&eb);    Clock_Params_init(&ClockParams);    ClockParams.startFlag = false; // Requires Clock_start    // ClockParams.period = microsecondsToClockCycles(ClockPeriod_ms); // ms to be translated into ticks    // ClockHandle = Clock_create( (Clock_FuncPtr)ClockFunction, microsecondsToClockCycles(ClockTimeOut_ms), &ClockParams, &eb);    // Surprisingly, period already defined in ms for ClockParams.period andClockTimeOut_ms    ClockParams.period = ClockPeriod_ms;    ClockHandle = Clock_create( (Clock_FuncPtr)ClockFunction, ClockTimeOut_ms, &ClockParams, &eb);    if (ClockHandle == NULL)    {        // Serial.println("*** Clock create failed");        System_abort("Clock create failed");    }}

/* *  ======== HWI_dispatchPlug ======== *  Plug the HWI dispatcher table. */Void HWI_dispatchPlug(Int vecid, Fxn fxn, HWI_Attrs *attrs){    Hwi_Params hwiParams;    Hwi_Handle hwi;    Error_Block eb;    if (attrs == NULL) {        attrs = &HWI_ATTRS;    }    Hwi_Params_init(&hwiParams);    Error_init(&eb);    if (attrs->ierMask == 1) {        hwiParams.maskSetting = Hwi_MaskingOption_SELF;    }    else {        hwiParams.maskSetting = Hwi_MaskingOption_BITMASK;    }        hwiParams.disableMask = hwiParams.restoreMask = attrs->ierMask;    hwiParams.arg = attrs->arg;    hwiParams.enableInt = FALSE;     /*      * Tell the BIOS6 dispatcher not to ACK interrupts because the BIOS5     * dispatcher doesn't ACK interrupts     */    hwiParams.enableAck = FALSE;    hwi = Hwi_getHandle(vecid);    if (hwi == NULL) {        Hwi_create(vecid, (Hwi_FuncPtr)fxn, &hwiParams, &eb);    }    else {        Hwi_reconfig(hwi, (Hwi_FuncPtr)fxn, &hwiParams);    }}

/* *  ======== LoggerBuf_setFilterLevel ======== *  Sets the filter level for the given diags level. * *  LoggerBuf maintains a separate filter level for every diags category. This *  is accomplished by maintaining three masks, one for each of the levels 1 -  *  3, wich store the diags categories which are currently at that level. There *  is no mask for level4; if the diags category is not found in levels 1-3, it *  is  assumed that the filtering level is level4. * *  This API is an instance function per the IFilterLogger interface, but  *  LoggerBuf only maintains module-wide filter levels. * *  TODO - Should this be conditional on the 'filterByLevel' config? */Void LoggerBuf_setFilterLevel(LoggerBuf_Object *obj, Diags_Mask mask,                               Diags_EventLevel filterLevel){       /*      * First, remove the bits in 'mask' from all of the current 'level' masks.     * Use level = (~(mask & level) & level) to remove 'mask' bits from all      * 'level's.     *    1. AND mask and level to get set of bits that appear in both     *    2. Take the inverse of this set and AND it with 'level' to disable     *       any bits which appear in 'mask'.     */    LoggerBuf_module->level1 = ~(LoggerBuf_module->level1 & mask) &                                LoggerBuf_module->level1;    LoggerBuf_module->level2 = ~(LoggerBuf_module->level2 & mask) &                                LoggerBuf_module->level2;        LoggerBuf_module->level3 = ~(LoggerBuf_module->level3 & mask) &                                LoggerBuf_module->level3;            /* Enable the bits specified in 'mask' in the appropriate level. */    switch (filterLevel) {        case Diags_LEVEL1:            LoggerBuf_module->level1 |= mask;            break;        case Diags_LEVEL2:            LoggerBuf_module->level2 |= mask;            break;        case Diags_LEVEL3:            LoggerBuf_module->level3 |= mask;            break;        case Diags_LEVEL4:            break;        default: {            /* Raise an error that a bad filter level was received. */            Error_Block eb;            Error_init(&eb);            Error_raise(&eb, LoggerBuf_E_badLevel, filterLevel, 0);            break;        }    }}

/* *  ======== Board_initDMA ======== */void Board_initDMA(void){    Error_Block eb;    Hwi_Params  hwiParams;    if (!dmaInitialized) {        Error_init(&eb);        Hwi_Params_init(&hwiParams);        Hwi_construct(&(hwiStruct), INT_UDMAERR, Board_errorDMAHwi,                      &hwiParams, &eb);        if (Error_check(&eb)) {            System_abort("Couldn't create DMA error hwi");        }        MAP_PRCMPeripheralClkEnable(PRCM_UDMA, PRCM_RUN_MODE_CLK);        MAP_PRCMPeripheralReset(PRCM_UDMA);        MAP_uDMAEnable();        MAP_uDMAControlBaseSet(dmaControlTable);        dmaInitialized = true;    }}

/* *  ======== EK_TM4C123GXL_initDMA ======== */void EK_TM4C123GXL_initDMA(void) {	Error_Block eb;	Hwi_Params hwiParams;	if (!DMA_initialized) {		Error_init(&eb);		Hwi_Params_init(&hwiParams);		Hwi_construct(&(hwiStruct), INT_UDMAERR, EK_TM4C123GXL_errorDMAHwi,				&hwiParams, &eb);		if (Error_check(&eb)) {			System_abort("Couldn't create DMA error hwi");		}		SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);		uDMAEnable();		uDMAControlBaseSet(EK_TM4C123GXL_DMAControlTable);		DMA_initialized = true;	}}

/* *  ======== MessageQ_open ======== */Int MessageQ_open(String name, MessageQ_QueueId *queueId){    Int         status;    Error_Block eb;    Assert_isTrue(name != NULL, ti_sdo_ipc_MessageQ_A_invalidParam);    Assert_isTrue(queueId != NULL, ti_sdo_ipc_MessageQ_A_invalidParam);    Error_init(&eb);        /* Search NameServer */    status = NameServer_getUInt32(            (NameServer_Handle)MessageQ_module->nameServer, name, queueId,             NULL);    if (status >= 0) {        return (MessageQ_S_SUCCESS);    /* name found */    }    else {        return (MessageQ_E_NOTFOUND);   /* name not found */    }}