=============================================================================
List of generated methods in project: MulticoreBuoy_Z4_0

This text description is generated by Processor Expert. Do not modify it.
=============================================================================

Module "pin_mux"   (component PinSettings)
   - pin_mux_PINS_DRV_Init -This function configures the pins with the options provided in the provided structure
   - pin_mux_PINS_DRV_SetPullSel -This function configures the internal resistor
   - pin_mux_PINS_DRV_SetOutputBuffer -This function configures the output buffer
   - pin_mux_PINS_DRV_SetInputBuffer -This function configures the input buffer
   - pin_mux_PINS_DRV_ConfigIntFilterClock -This function configures the interrupt filter clock prescaler
   - pin_mux_PINS_DRV_SetExInt -This function configures the external interrupt
   - pin_mux_PINS_DRV_ClearPinExIntFlag -This function clears the individual pin external interrupt status flag
   - pin_mux_PINS_DRV_GetPinExIntFlag -This function gets the individual pin external interrupt status flag
   - pin_mux_PINS_DRV_ClearExIntFlag -This function clears the entire external interrupt status flag
   - pin_mux_PINS_DRV_GetExIntFlag -This function gets the individual pin external interrupt status flag
   - pin_mux_PINS_DRV_WritePin -This function writes the given pin from a port, with the given value ('0' represents LOW, '1' 
                represents HIGH)
   - pin_mux_PINS_DRV_WritePins -This function writes all pins configured as output with the values given in the parameter pins.
                '0' represents LOW, '1' represents HIGH
   - pin_mux_PINS_DRV_GetPinsOutput -This function returns the current output that is written to a port. Only pins that are 
                configured as output will have meaningful values
   - pin_mux_PINS_DRV_SetPins -This function configures output pins listed in parameter pins (bits that are '1') to have a 
                value of 'set' (HIGH). Pins corresponding to '0' will be unaffected
   - pin_mux_PINS_DRV_ClearPins -This function configures output pins listed in parameter pins (bits that are '1') to have a 
                'cleared' value (LOW). Pins corresponding to '0' will be unaffected
   - pin_mux_PINS_DRV_TogglePins -This function toggles output pins listed in parameter pins (bits that are '1'). Pins 
                corresponding to '0' will be unaffected
   - pin_mux_PINS_DRV_ReadPins -This function returns the current input values from a port. Only pins configured as input will 
                have meaningful values

Module "clockMan1" (component clock_manager)
   - clockMan1_CLOCK_DRV_Init -Initialize clocking modules
   - clockMan1_CLOCK_DRV_GetFreq -Return frequency.

Module "intMan1"   (component interrupt_manager)
   - intMan1_INT_SYS_InstallHandler -Installs an interrupt handler routine for a given IRQ number.
   - intMan1_INT_SYS_EnableIRQ -Enables an interrupt for a given IRQ number.
   - intMan1_INT_SYS_DisableIRQ -Disables an interrupt for a given IRQ number.
   - intMan1_INT_SYS_EnableIRQGlobal -Enables system interrupt.
   - intMan1_INT_SYS_DisableIRQGlobal -Disable system interrupt.
   - intMan1_INT_SYS_SetPriority -Set Interrupt Priority.
   - intMan1_INT_SYS_GetPriority -Get Interrupt Priority.
   - intMan1_INT_SYS_SetSoftwareIRQRequest -Set software interrupt request.
   - intMan1_INT_SYS_ClearSoftwareIRQRequest -Clear software interrupt request.
   - intMan1_INT_SYS_EnableIRQ_MC -Enables an interrupt for a given IRQ number, on the given cores.
   - intMan1_INT_SYS_GetCoresForIRQ -Gets the cores on which an interrupt for the specified IRQ number is enabled.
   - intMan1_INT_SYS_DisableIRQ_MC -Disables an interrupt for a given IRQ number, on the given cores.
   - intMan1_INT_SYS_DisableIRQ_MC_All -Disables an interrupt for a given IRQ number, on all cores.

Module "FreeRTOS"  (component FreeRTOS)
   - FreeRTOS_xCoRoutineCreate -Create a new co-routine and add it to the list of co-routines that are ready to run.
   - FreeRTOS_crDELAY -Delay a co-routine for a fixed period of time. crDELAY can only be called from the co-routine function 
                itself - not from within a function called by the co-routine function. This is because co-routines do not 
                maintain their own stack.
   - FreeRTOS_crQUEUE_SEND -crQUEUE_SEND is a macro. The macro's crQUEUE_SEND() and crQUEUE_RECEIVE() are the co-routine 
                equivalent to the xQueueSend() and xQueueReceive() functions used by tasks.
   - FreeRTOS_crQUEUE_RECEIVE -crQUEUE_RECEIVE is a macro. The macro's crQUEUE_SEND() and crQUEUE_RECEIVE() are the co-routine 
                equivalent to the xQueueSend() and xQueueReceive() functions used by tasks.
   - FreeRTOS_crQUEUE_SEND_FROM_ISR -crQUEUE_SEND_FROM_ISR() is a macro. The macro's crQUEUE_SEND_FROM_ISR() and 
                crQUEUE_RECEIVE_FROM_ISR() are the co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR() 
                functions used by tasks.
   - FreeRTOS_crQUEUE_RECEIVE_FROM_ISR -crQUEUE_SEND_FROM_ISR() is a macro. The macro's crQUEUE_SEND_FROM_ISR() and 
                crQUEUE_RECEIVE_FROM_ISR() are the co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR() 
                functions used by tasks.
   - FreeRTOS_vCoRoutineSchedule -vCoRoutineSchedule() executes the highest priority co-routine that is able to run. The 
                co-routine will execute until it either blocks, yields or is preempted by a task. Co-routines execute 
                cooperatively so one co-routine cannot be preempted by another, but can be preempted by a task.
   - FreeRTOS_xEventGroupCreate -Create a new RTOS event group. This function cannot be called from an interrupt. Event groups 
                are stored in variables of type EventGroupHandle_t. The number of bits (or flags) implemented within an event 
                group is 8 if configUSE_16_BIT_TICKS is set to 1, or 24 if configUSE_16_BIT_TICKS is set to 0. The dependency 
                on configUSE_16_BIT_TICKS results from the data type used for thread local storage in the internal 
                implementation of RTOS tasks.
   - FreeRTOS_xEventGroupClearBits -Clear bits (flags) within an RTOS event group. This function cannot be called from an 
                interrupt. See xEventGroupClearBitsFromISR() for a version that can be called from an interrupt.
   - FreeRTOS_xEventGroupClearBitsFromISR -A version of xEventGroupClearBits() that can be called from an interrupt.
   - FreeRTOS_vEventGroupDelete -Delete an event group that was previously created using a call to xEventGroupCreate().
   - FreeRTOS_xEventGroupGetBits -Returns the current value of the bits in an event group.  This function cannot be used from 
                an interrupt.
   - FreeRTOS_xEventGroupGetBitsFromISR -A version of xEventGroupGetBits() that can be called from an ISR.
   - FreeRTOS_xEventGroupSetBits -Set bits within an event group. This function cannot be called from an interrupt.  
                xEventGroupSetBitsFromISR() is a version that can be called from an interrupt.
   - FreeRTOS_xEventGroupSetBitsFromISR -A version of xEventGroupSetBits() that can be called from an interrupt. Setting bits 
                in an event group is not a deterministic operation because there are an unknown number of tasks that may be 
                waiting for the bit or bits being set.  FreeRTOS does not allow nondeterministic operations to be performed in 
                interrupts or from critical sections.  Therefore xEventGroupSetBitFromISR() sends a message to the timer task 
                to have the set operation performed in the context of the timer task - where a scheduler lock is used in place 
                of a critical section.
   - FreeRTOS_xEventGroupSync -Atomically set bits within an event group, then wait for a combination of bits to be set within 
                the same event group.  This functionality is typically used to synchronise multiple tasks, where each task has 
                to wait for the other tasks to reach a synchronisation point before proceeding. This function cannot be used 
                from an interrupt.
   - FreeRTOS_xEventGroupWaitBits -Read bits within an RTOS event group, optionally entering the Blocked state (with a timeout) 
                to wait for a bit or group of bits to become set. This function cannot be called from an interrupt.
   - FreeRTOS_vQueueAddToRegistry -Assigns a name to a queue and adds the queue to the registry.
   - FreeRTOS_xQueueAddToSet -Adds an RTOS queue or semaphore to a queue set that was previously created by a call to 
                xQueueCreateSet(). A receive (in the case of a queue) or take (in the case of a semaphore) operation must not 
                be performed on a member of a queue set unless a call to xQueueSelectFromSet() has first returned a handle to 
                that set member.
   - FreeRTOS_xQueueCreate -Creates a new queue instance. This allocates the storage required by the new queue and returns a 
                handle for the queue.
   - FreeRTOS_xQueueCreateSet -Queue sets provide a mechanism to allow an RTOS task to block (pend) on a read operation from 
                multiple RTOS queues or semaphores simultaneously. Note that there are simpler alternatives to using queue sets.
                See the Blocking on Multiple Objects page for more information.
   - FreeRTOS_vQueueDelete -Delete a queue - freeing all the memory allocated for storing of items placed on the queue.
   - FreeRTOS_xQueueIsQueueEmptyFromISR -Queries a queue to determine if the queue is empty. This function should only be used 
                in an ISR.
   - FreeRTOS_xQueueIsQueueFullFromISR -Queries a queue to determine if the queue is full. This function should only be used in 
                an ISR.
   - FreeRTOS_uxQueueMessagesWaiting -A version of uxQueueMessagesWaiting() that can be called from an ISR. Return the number 
                of messages stored in a queue.
   - FreeRTOS_uxQueueMessagesWaitingFromISR -This is a macro that calls the xQueueGenericSend() function. A version of 
                xQueueSendToBack() that will write to the queue even if the queue is full, overwriting data that is already 
                held in the queue.
   - FreeRTOS_xQueueOverwriteFromISR -This is a macro that calls the xQueueGenericSendFromISR() function. A version of 
                xQueueOverwrite() that can be used in an ISR. xQueueOverwriteFromISR() is similar to xQueueSendToBackFromISR(), 
                but will write to the queue even if the queue is full, overwriting data that is already held in the queue.
   - FreeRTOS_xQueuePeek -This is a macro that calls the xQueueGenericReceive() function. Receive an item from a queue without 
                removing the item from the queue. The item is received by copy so a buffer of adequate size must be provided. 
                The number of bytes copied into the buffer was defined when the queue was created.
   - FreeRTOS_xQueuePeekFromISR -A version of xQueuePeek() that can be used from an interrupt service routine (ISR). Receive an 
                item from a queue without removing the item from the queue. The item is received by copy so a buffer of 
                adequate size must be provided. The number of bytes copied into the buffer was defined when the queue was 
                created.
   - FreeRTOS_xQueueReceive -This is a macro that calls the xQueueGenericReceive() function. Receive an item from a queue. The 
                item is received by copy so a buffer of adequate size must be provided. The number of bytes copied into the 
                buffer was defined when the queue was created.
   - FreeRTOS_xQueueReceiveFromISR -Receive an item from a queue. It is safe to use this function from within an interrupt 
                service routine.
   - FreeRTOS_xQueueRemoveFromSet -Remove an RTOS queue or semaphore from a queue set. An RTOS queue or semaphore can only be 
                removed from a queue set if the queue or semaphore is empty.
   - FreeRTOS_xQueueReset -Resets a queue to its original empty state.
   - FreeRTOS_xQueueSelectFromSet -xQueueSelectFromSet() selects from the members of a queue set a queue or semaphore that 
                either contains data (in the case of a queue) or is available to take (in the case of a semaphore). 
                xQueueSelectFromSet() effectively allows a task to block (pend) on a read operation on all the queues and 
                semaphores in a queue set simultaneously.
   - FreeRTOS_xQueueSelectFromSetFromISR -A version of xQueueSelectFromSet() that can be used from an interrupt service routine 
                (ISR).
   - FreeRTOS_xQueueSend -This is a macro that calls xQueueGenericSend(). It is included for backward compatibility with 
                versions of FreeRTOS that did not include the xQueueSendToFront() and xQueueSendToBack() macros. It is 
                equivalent to xQueueSendToBack().
   - FreeRTOS_xQueueSendToFront -This is a macro that calls xQueueGenericSend(). Post an item to the front of a queue. The item 
                is queued by copy, not by reference. This function must not be called from an interrupt service routine. See 
                xQueueSendToFrontFromISR () for an alternative which may be used in an ISR.
   - FreeRTOS_xQueueSendToBack -This is a macro that calls xQueueGenericSend(). It is equivalent to xQueueSend(). Post an item 
                to the back of a queue. The item is queued by copy, not by reference. This function must not be called from an 
                interrupt service routine. See xQueueSendToBackFromISR () for an alternative which may be used in an ISR.
   - FreeRTOS_xQueueSendFromISR -This is a macro that calls xQueueGenericSendFromISR(). It is included for backward 
                compatibility with versions of FreeRTOS that did not include the xQueueSendToBackFromISR() and 
                xQueueSendToFrontFromISR() macros. Post an item into the back of a queue. It is safe to use this function from 
                within an interrupt service routine.
   - FreeRTOS_xQueueSendToBackFromISR -This is a macro that calls xQueueGenericSendFromISR(). Post an item to the back of a 
                queue. It is safe to use this function from within an interrupt service routine.
   - FreeRTOS_xQueueSendToFrontFromISR -This is a macro that calls xQueueGenericSendFromISR(). Post an item to the front of a 
                queue. It is safe to use this function from within an interrupt service routine.
   - FreeRTOS_uxQueueSpacesAvailable -Return the number of free spaces in a queue.
   - FreeRTOS_vSemaphoreCreateBinary -Macro that creates a semaphore by using the existing queue mechanism. The queue length is 
                1 as this is a binary semaphore. The data size is 0 as we don't want to actually store any data - we just want 
                to know if the queue is empty or full.
   - FreeRTOS_xSemaphoreCreateBinary -Function that creates a binary semaphore. Binary semaphores are either available, or not 
                available, hence binary. The semaphore is created in the 'empty' state, meaning the semaphore must first be 
                given before it can be taken (obtained) using the xSemaphoreTake() function.
   - FreeRTOS_xSemaphoreCreateCounting -Macro that creates a counting semaphore by using the existing queue mechanism. Counting 
                semaphores are typically used for two things:      1. Counting events.   2. Resource management.
   - FreeRTOS_xSemaphoreCreateMutex -Macro that creates a mutex semaphore by using the existing queue mechanism. Mutexes 
                created using this macro can be accessed using the xSemaphoreTake() and xSemaphoreGive() macros. The 
                xSemaphoreTakeRecursive() and xSemaphoreGiveRecursive() macros should not be used.
   - FreeRTOS_xSemaphoreCreateRecursiveMutex -Macro that implements a recursive mutex by using the existing queue mechanism. 
                Mutexes created using this macro can be accessed using the xSemaphoreTakeRecursive() and 
                xSemaphoreGiveRecursive() macros. The xSemaphoreTake() and xSemaphoreGive() macros should not be used.
   - FreeRTOS_vSemaphoreDelete -Deletes a semaphore, including mutex type semaphores and recursive semaphores. Do not delete a 
                semaphore that has tasks blocked on it (tasks that are in the Blocked state waiting for the semaphore to become 
                available).
   - FreeRTOS_xSemaphoreGetMutexHolder -Return the handle of the task that holds the mutex specified by the function parameter, 
                if any.
   - FreeRTOS_xSemaphoreGive -Macro to release a semaphore. The semaphore must have previously been created with a call to 
                xSemaphoreCreateBinary(), xSemaphoreCreateMutex() or xSemaphoreCreateCounting(), and obtained using 
                sSemaphoreTake().
   - FreeRTOS_xSemaphoreGiveFromISR -Macro to release a semaphore. The semaphore must have previously been created with a call 
                to xSemaphoreCreateBinary() or xSemaphoreCreateCounting().
   - FreeRTOS_xSemaphoreGiveRecursive -Macro to recursively release, or 'give', a mutex type semaphore. The mutex must have 
                previously been created using a call to xSemaphoreCreateRecursiveMutex();
   - FreeRTOS_xSemaphoreTake -Macro to obtain a semaphore. The semaphore must have previously been created with a call to 
                xSemaphoreCreateBinary(), xSemaphoreCreateMutex() or xSemaphoreCreateCounting().
   - FreeRTOS_xSemaphoreTakeFromISR -A version of xSemaphoreTake() that can be called from an ISR. Unlike xSemaphoreTake(), 
                xSemaphoreTakeFromISR() does not permit a block time to be specified.
   - FreeRTOS_xSemaphoreTakeRecursive -Macro to recursively obtain, or 'take', a mutex type semaphore. The mutex must have 
                previously been created using a call to xSemaphoreCreateRecursiveMutex();    configUSE_RECURSIVE_MUTEXES must 
                be set to 1 in FreeRTOSConfig.h for this macro to be available.   This macro must not be used on mutexes 
                created using xSemaphoreCreateMutex().
   - FreeRTOS_xTimerChangePeriod -Timer functionality is provided by a timer service/daemon task. Many of the public FreeRTOS 
                timer API functions send commands to the timer service task through a queue called the timer command queue. The 
                timer command queue is private to the RTOS kernel itself and is not directly accessible to application code. 
                The length of the timer command queue is set by the configTIMER_QUEUE_LENGTH configuration constant.
   - FreeRTOS_xTimerChangePeriodFromISR -A version of xTimerStop() that can be called from an interrupt service routine.
   - FreeRTOS_xTimerCreate -Creates a new software timer instance. This allocates the storage required by the new timer, 
                initialises the new timers internal state, and returns a handle by which the new timer can be referenced.
   - FreeRTOS_xTimerDelete -pdFAIL will be returned if the delete command could not be sent to the timer command queue even 
                after xBlockTime ticks had passed. pdPASS will be returned if the command was successfully sent to the timer 
                command queue. When the command is actually processed will depend on the priority of the timer service/daemon 
                task relative to other tasks in the system. The timer service/daemon task priority is set by the 
                configTIMER_TASK_PRIORITY configuration constant.
   - FreeRTOS_xTimerGetTimerDaemonTaskHandle -INCLUDE_xTimerGetTimerDaemonTaskHandle and configUSE_TIMERS must both be set to 1 
                in FreeRTOSConfig.h for xTimerGetTimerDaemonTaskHandle() to be available.
   - FreeRTOS_pvTimerGetTimerID -Returns the ID assigned to the timer.
   - FreeRTOS_pcTimerGetName -Returns the human readable name assigned to a timer when the timer was created.
   - FreeRTOS_xTimerIsTimerActive -Queries a timer to see if it is active or dormant. A timer will be dormant if:      1. It 
                has been created but not started, or   2. It is an expired one-shot timer that has not been restarted.
   - FreeRTOS_xTimerPendFunctionCall -Used to pend the execution of a function to the RTOS daemon task (the timer service task, 
                hence this function is pre-fixed with 'Timer').
   - FreeRTOS_xTimerPendFunctionCallFromISR -Used to pend the execution of a function to the RTOS daemon task (the timer 
                service task, hence this function is pre-fixed with 'Timer').
   - FreeRTOS_xTimerReset -Timer functionality is provided by a timer service/daemon task. Many of the public FreeRTOS timer 
                API functions send commands to the timer service task through a queue called the timer command queue. The timer 
                command queue is private to the RTOS kernel itself and is not directly accessible to application code. The 
                length of the timer command queue is set by the configTIMER_QUEUE_LENGTH configuration constant.
   - FreeRTOS_xTimerResetFromISR -A version of xTimerReset() that can be called from an interrupt service routine.
   - FreeRTOS_xTimerStart -Timer functionality is provided by a timer service/daemon task. Many of the public FreeRTOS timer 
                API functions send commands to the timer service task through a queue called the timer command queue. The timer 
                command queue is private to the RTOS kernel itself and is not directly accessible to application code. The 
                length of the timer command queue is set by the configTIMER_QUEUE_LENGTH configuration constant.
   - FreeRTOS_xTimerStartFromISR -A version of xTimerStart() that can be called from an interrupt service routine.
   - FreeRTOS_xTimerStop -Timer functionality is provided by a timer service/daemon task. Many of the public FreeRTOS timer API 
                functions send commands to the timer service task through a queue called the timer command queue. The timer 
                command queue is private to the RTOS kernel itself and is not directly accessible to application code. The 
                length of the timer command queue is set by the configTIMER_QUEUE_LENGTH configuration constant.
   - FreeRTOS_xTimerStopFromISR -A version of xTimerStart() that can be called from an interrupt service routine.
   - FreeRTOS_vTaskAllocateMPURegions -Memory regions are assigned to a restricted task when the task is created using a call 
                to xTaskCreateRestricted(). The regions can then be modified or redefined at run time using 
                vTaskAllocateMPURegions().
   - FreeRTOS_xTaskCreate -Create a new task and add it to the list of tasks that are ready to run. If you are using 
                FreeRTOS-MPU then it is recommended to use xTaskCreateRestricted() in place of xTaskCreate(). Using 
                xTaskCreate() with FreeRTOS-MPU allows tasks to be created to run in either Privileged or User modes (see the 
                description of uxPriority below). When Privileged mode it used the task will have access to the entire memory 
                map, when User mode is used the task will have access to only its stack. In both cases the MPU will not 
                automatically catch stack overflows, although the standard FreeRTOS stack overflow detection schemes can still 
                be used. xTaskCreateRestricted() permits much greater flexibility.
   - FreeRTOS_xTaskCreateRestricted -Create a new Memory Protection Unit (MPU) restricted task and add it to the list of tasks 
                that are ready to run.
   - FreeRTOS_vTaskDelay -Delay a task for a given number of ticks. The actual time that the task remains blocked depends on 
                the tick rate. The constant portTICK_PERIOD_MS can be used to calculate real time from the tick rate - with the 
                resolution of one tick period.
   - FreeRTOS_vTaskDelayUntil -Delay a task until a specified time. This function can be used by periodic tasks to ensure a 
                constant execution frequency.
   - FreeRTOS_vTaskDelete -Remove a task from the RTOS kernels management. The task being deleted will be removed from all 
                ready, blocked, suspended and event lists.
   - FreeRTOS_taskDISABLE_INTERRUPTS -Macro to disable all maskable interrupts.
   - FreeRTOS_taskENABLE_INTERRUPTS -Macro to enable microcontroller interrupts.
   - FreeRTOS_taskENTER_CRITICAL -Macro to mark the start of a critical code region. Preemptive context switches cannot occur 
                when in a critical region.
   - FreeRTOS_taskEXIT_CRITICAL -Macro to mark the end of a critical code region. Preemptive context switches cannot occur when 
                in a critical region.
   - FreeRTOS_xTaskGetApplicationTaskTag -Returns the ‘tag’ value associated with a task. The meaning and use of the tag value 
                is defined by the application writer. The RTOS kernel itself will not normally access the tag value.
   - FreeRTOS_xTaskGetCurrentTaskHandle -Returns the handle of the currently running (calling) task.
   - FreeRTOS_xTaskGetIdleTaskHandle -Returns the task handle associated with the Idle task.
   - FreeRTOS_uxTaskGetNumberOfTasks -Return the number of tasks that the RTOS kernel is currently managing.
   - FreeRTOS_vTaskGetRunTimeStats -Return information on the amount of processing time that has been used by each task. This 
                function can then be used to present this information in a tabular format.
   - FreeRTOS_xTaskGetSchedulerState -Returns the scheduler state.
   - FreeRTOS_uxTaskGetStackHighWaterMark -Returns the high water mark of the stack associated with xTask.  That is, the 
                minimum free stack space there has been (in words, so on a 32 bit machine a value of 1 means 4 bytes) since the 
                task started.  The smaller the returned number the closer the task has come to overflowing its stack.
   - FreeRTOS_eTaskGetState -Returns as an enumerated type the state in which a task existed at the time eTaskGetState() was 
                executed.
   - FreeRTOS_uxTaskGetSystemState -Populates an TaskStatus_t structure for each task in the system.  TaskStatus_t structures 
                contain, among other things, members for the task handle, task name, task priority, task state, and total 
                amount of run time consumed by the task.  See the TaskStatus_t structure definition in this file for the full 
                member list.
   - FreeRTOS_xTaskGetTickCount -This function cannot be called from an ISR. Use xTaskGetTickCountFromISR() instead.
   - FreeRTOS_xTaskGetTickCountFromISR -A version of xTaskGetTickCount() that can be called from an ISR.
   - FreeRTOS_vTaskList -vTaskList() is a utility function provided for convenience only. It is not considered part of the 
                kernel.
   - FreeRTOS_uxTaskPriorityGet -Return the priority of any task.
   - FreeRTOS_vTaskPrioritySet -Set the priority of any task.
   - FreeRTOS_vTaskResume -Resumes a suspended task. A task that has been suspended by one or more calls to vTaskSuspend () 
                will be made available for running again by a single call to vTaskResume ().
   - FreeRTOS_xTaskResumeAll -Resumes the scheduler after it was suspended using a call to vTaskSuspendAll(). xTaskResumeAll() 
                only resumes the scheduler. It does not unsuspend tasks that were previously suspended by a call to 
                vTaskSuspend().
   - FreeRTOS_xTaskResumeFromISR -A function to resume a suspended task that can be called from within an ISR. A task that has 
                been suspended by one of more calls to vTaskSuspend() will be made available for running again by a single call 
                to xTaskResumeFromISR().
   - FreeRTOS_vTaskSetApplicationTaskTag -Set 'tag' value to each task. This value is for the use of the application only - the 
                RTOS kernel itself does not make use of it in any way.
   - FreeRTOS_vTaskStepTick -If the RTOS is configured to use tickless idle functionality then the tick interrupt will be 
                stopped, and the microcontroller placed into a low power state, whenever the Idle task is the only task able to 
                execute. Upon exiting the low power state the tick count value must be corrected to account for the time that 
                passed while it was stopped.
   - FreeRTOS_vTaskSuspend -uspend any task. When suspended a task will never get any microcontroller processing time, no 
                matter what its priority.
   - FreeRTOS_vTaskSuspendAll -Suspends the scheduler without disabling interrupts. Context switches will not occur while the 
                scheduler is suspended. RTOS ticks that occur while the scheduler is suspended will be held pending until the 
                scheduler has been unsuspended using a call to xTaskResumeAll().
   - FreeRTOS_taskYIELD -Macro for forcing a context switch.
   - FreeRTOS_vTaskStartScheduler -Starts the RTOS scheduler. After calling the RTOS kernel has control over which tasks are 
                executed and when. The idle task and optionally the timer daemon task are created automatically when the RTOS 
                scheduler is started.
   - FreeRTOS_vTaskEndScheduler -Stops the RTOS kernel tick. All created tasks will be automatically deleted and multitasking 
                (either preemptive or cooperative) will stop. Execution then resumes from the point where vTaskStartScheduler() 
                was called, as if vTaskStartScheduler() had just returned.
   - FreeRTOS_xTaskCallApplicationTaskHook -Calls the hook function associated with xTask. Passing xTask as NULL has the effect 
                of calling the Running tasks (the calling task) hook function.

Module "sdhc_middleware" (component sdhc)
   - sdhc_middleware_uSDHC_fatfs_initialize -uSDHC fatfs callbacks initialization routine. Must be called before FATFS use.
   - sdhc_middleware_uSDHC_Init -Check whether uSDHC could be initialized, loops on error. This function calls SD_Deinit() and 
                uSDHC driver de-initialization routine.
   - sdhc_middleware_uSDHC_DeInit -Should be called if uSDHC shouldn't be used anymore.
   - sdhc_middleware_uSDHC_IsSDCardPresent -Check whether the card is present in slot. This function returns card instance 
                structure.
   - sdhc_middleware_uSDHC_IsSDCardWriteProtect -Check whether the card is write-protected. True if card has write protection 
                switch position is locked.

Module "fatfs_middleware" (component fatfs)
   - fatfs_middleware_f_open -Open or create a file.
   - fatfs_middleware_f_close -Close an open file object.
   - fatfs_middleware_f_read -Read data from the file.
   - fatfs_middleware_f_write -Write data to the file.
   - fatfs_middleware_f_lseek -Move file pointer of the file object.
   - fatfs_middleware_f_truncate -Truncate the file.
   - fatfs_middleware_f_sync -Flush cached data of the writing file.
   - fatfs_middleware_f_opendir -Open a directory.
   - fatfs_middleware_f_closedir -Close a directory.
   - fatfs_middleware_f_readdir -Read Directory Entries in Sequence.
   - fatfs_middleware_f_findfirst -Find first file.
   - fatfs_middleware_f_findnext -Find next file.
   - fatfs_middleware_f_mkdir -Create new directory.
   - fatfs_middleware_f_unlink -Delete an existing file or directory.
   - fatfs_middleware_f_rename -Move/rename existing file or directory.
   - fatfs_middleware_f_stat -Get file status.
   - fatfs_middleware_f_chmod -Change attribute of a file/dir.
   - fatfs_middleware_f_utime -Change timestamp of a file/dir.
   - fatfs_middleware_f_chdir -Change current directory.
   - fatfs_middleware_f_chdrive -Change current drive.
   - fatfs_middleware_f_getcwd -Get current directory.
   - fatfs_middleware_f_getfree -Get number of free clusters on the drive.
   - fatfs_middleware_f_getlabel -Get volume label.
   - fatfs_middleware_f_setlabel -Set volume label.
   - fatfs_middleware_f_forward -Forward data to the stream.
   - fatfs_middleware_f_expand -Allocate a contiguous block to the file.
   - fatfs_middleware_f_mount -Mount/Unmount a logical drive.
   - fatfs_middleware_f_mkfs -Create a FAT volume.
   - fatfs_middleware_f_fdisk -Divide a physical drive into some partitions.
   - fatfs_middleware_f_putc -Put a character to the file.
   - fatfs_middleware_f_puts -Put a string to the file.
   - fatfs_middleware_f_printf -Put a formatted string to the file.
   - fatfs_middleware_f_gets -Get a string from the file.

Module "usdhc1"    (component usdhc)
   - usdhc1_uSDHC_DRV_GetDefaultConfig -Gets the default configuration structure.
   - usdhc1_uSDHC_DRV_Init -Initializes a uSDHC module.
   - usdhc1_uSDHC_DRV_Deinit -Shuts down the uSDHC module.
   - usdhc1_uSDHC_DRV_Reset -Reset the uSDHC module.
   - usdhc1_uSDHC_DRV_InstallCallback -Register the callback function.
   - usdhc1_uSDHC_DRV_GetCapability -Get supported capability of uSDHC module.
   - usdhc1_uSDHC_DRV_SetBusClock -Set frequency for the CLK pin. The read/write speed will depend on this frequency.
   - usdhc1_uSDHC_DRV_SetCardActive -Send 80 clock cycles to the card to activate the card.
   - usdhc1_uSDHC_DRV_SetDataBusWidth -Set data bus width for uSDHC module.
   - usdhc1_uSDHC_DRV_TransferBlocking -Transfer command/data using blocking mode.
   - usdhc1_uSDHC_DRV_Transfer -Transfer command/data using non-blocking mode.
   - usdhc1_uSDHC_DRV_EnableCardControl -Enable or disable some features for uSDHC.
   - usdhc1_uSDHC_DRV_GetPresentStatusFlags -This function is used to get the status of uSDHC.

Module "osif1"     (component osif)
   - osif1_OSIF_TimeDelay -Delays execution for a number of milliseconds.
   - osif1_OSIF_MutexLock -Waits for a mutex and locks it.
   - osif1_OSIF_MutexUnlock -Unlocks a previously locked mutex.
   - osif1_OSIF_MutexCreate -Create an unlocked mutex.
   - osif1_OSIF_MutexDestroy -Destroys a previously created mutex.
   - osif1_OSIF_SemaWait -Decrement a semaphore with timeout.
   - osif1_OSIF_SemaPost -Increment a semaphore.
   - osif1_OSIF_SemaCreate -Creates a semaphore with a given value.
   - osif1_OSIF_SemaDestroy -Destroys a previously created semaphore.
   - osif1_OSIF_GetMilliseconds -Returns the number of miliseconds elapsed since starting the internal timer or starting the 
                scheduler.

Module "linflexd_uart1" (component linflexd_uart)
   - linflexd_uart1_LINFLEXD_UART_DRV_SetBaudRate -Sets the baudrate for UART communication.
   - linflexd_uart1_LINFLEXD_UART_DRV_GetBaudRate -Retrieves the baudrate of UART communication.
   - linflexd_uart1_LINFLEXD_UART_DRV_Init -Initializes an UART operation instance.
   - linflexd_uart1_LINFLEXD_UART_DRV_Deinit -Shuts down the UART by disabling interrupts and transmitter/receiver.
   - linflexd_uart1_LINFLEXD_UART_DRV_InstallRxCallback -Installs callback function for the UART receive.
   - linflexd_uart1_LINFLEXD_UART_DRV_InstallTxCallback -Installs callback function for the UART transmit.
   - linflexd_uart1_LINFLEXD_UART_DRV_InstallErrorCallback -Installs callback function for the UART error cases.
   - linflexd_uart1_LINFLEXD_UART_DRV_SendDataBlocking -Sends data out through the UART module using a blocking method.
   - linflexd_uart1_LINFLEXD_UART_DRV_SendData -Sends data out through the UART module using a non-blocking method. This 
                enables an a-sync method for transmitting data. When used with a non-blocking receive, the UART can perform a 
                full duplex operation. Non-blocking means that the function returns immediately. The application has to get the 
                transmit status to know when the transmit is complete.
   - linflexd_uart1_LINFLEXD_UART_DRV_GetTransmitStatus -Returns whether the previous transmit is complete.
   - linflexd_uart1_LINFLEXD_UART_DRV_AbortSendingData -Terminates a non-blocking transmission early.
   - linflexd_uart1_LINFLEXD_UART_DRV_ReceiveDataBlocking -Gets data from the UART module by using a blocking method. Blocking 
                means that the function does not return until the receive is complete.
   - linflexd_uart1_LINFLEXD_UART_DRV_ReceiveData -Gets data from the UART module by using a non-blocking method. This enables 
                an a-sync method for receiving data. When used with a non-blocking transmission, the UART can perform a full 
                duplex operation. Non-blocking means that the function returns immediately. The application has to get the 
                receive status to know when the receive is complete.
   - linflexd_uart1_LINFLEXD_UART_DRV_GetReceiveStatus -Returns whether the previous receive is complete.
   - linflexd_uart1_LINFLEXD_UART_DRV_AbortReceivingData -Terminates a non-blocking receive early.
   - linflexd_uart1_LINFLEXD_UART_DRV_SetTxBuffer -Updates the internal reference to the tx buffer.
   - linflexd_uart1_LINFLEXD_UART_DRV_SetRxBuffer -Updates the internal reference to rx buffer.

Module "dmaController1" (component edma)
   - dmaController1_EDMA_DRV_Init -Initializes the eDMA module.
   - dmaController1_EDMA_DRV_Deinit -Shuts down the eDMA module.
   - dmaController1_EDMA_DRV_ChannelInit -Initializes a eDMA virtualChannel.
   - dmaController1_EDMA_DRV_ReleaseChannel -Releases an eDMA virtualChannel.
   - dmaController1_EDMA_DRV_StartChannel -Starts an eDMA virtualChannel.
   - dmaController1_EDMA_DRV_StopChannel -Stops the eDMA virtualChannel.
   - dmaController1_EDMA_DRV_InstallCallback -Registers the callback function and the parameter for eDMA virtualChannel.
   - dmaController1_EDMA_DRV_GetChannelStatus -Gets the eDMA virtualChannel status.
   - dmaController1_EDMA_DRV_PushConfigToReg -Copies the virtualChannel configuration to the TCD registers.
   - dmaController1_EDMA_DRV_PushConfigToSTCD -Copies the virtualChannel configuration to the software TCD structure.
   - dmaController1_EDMA_DRV_ConfigSingleBlockTransfer -Configures a simple single block data transfer with DMA. This function 
                configures the descriptor for a single block transfer.
   - dmaController1_EDMA_DRV_ConfigLoopTransfer -Configures the DMA transfer in loop mode.
   - dmaController1_EDMA_DRV_ConfigScatterGatherTransfer -Configures the DMA transfer in a scatter-gather mode.
   - dmaController1_EDMA_DRV_ConfigMultiBlockTransfer -Configures a multiple block data transfer with DMA. This function 
                configures the descriptor for a multi block transfer.
   - dmaController1_EDMA_DRV_CancelTransfer -Cancels the remaining data transfer.
   - dmaController1_EDMA_DRV_SetChannelRequestAndTrigger -Configures the DMA request and periodic trigger for the eDMA channel.
   - dmaController1_EDMA_DRV_ClearTCD -Clears all registers to 0 for the virtualChannel's TCD.
   - dmaController1_EDMA_DRV_SetSrcAddr -Configures the source address for the eDMA virtualChannel.
   - dmaController1_EDMA_DRV_SetSrcOffset -Configures the source address signed offset for the eDMA virtualChannel.
   - dmaController1_EDMA_DRV_SetSrcReadChunkSize -Configures the source data chunk size (transferred in a read sequence).
   - dmaController1_EDMA_DRV_SetDestAddr -Configures the destination address for the eDMA virtualChannel.
   - dmaController1_EDMA_DRV_SetDestOffset -Configures the destination address signed offset for the eDMA virtualChannel.
   - dmaController1_EDMA_DRV_SetDestWriteChunkSize -Configures the destination data chunk size (transferred in a write sequence)
                .
   - dmaController1_EDMA_DRV_SetMinorLoopBlockSize -Configures the number of bytes to be transferred in each service request of 
                the virtualChannel.
   - dmaController1_EDMA_DRV_SetMajorLoopIterationCount -Configures the number of major loop iterations.
   - dmaController1_EDMA_DRV_GetRemainingMajorIterationsCount -Returns the remaining major loop iteration count.
   - dmaController1_EDMA_DRV_SetScatterGatherLink -Configures the memory address of the next TCD, in scatter/gather mode.
   - dmaController1_EDMA_DRV_DisableRequestsOnTransferComplete -Disables/Enables the DMA request after the major loop completes 
                for the TCD.
   - dmaController1_EDMA_DRV_SetSrcLastAddrAdjustment -Configures the source address last adjustment.
   - dmaController1_EDMA_DRV_SetDestLastAddrAdjustment -Configures the destination address last adjustment.
   - dmaController1_EDMA_DRV_ConfigureInterrupt -Disables/Enables the virtualChannel interrupt requests.
   - dmaController1_EDMA_DRV_TriggerSwRequest -Triggers a sw request for the current virtualChannel.

Module "rtcTimer1" (component rtc_api)
   - rtcTimer1_RTC_DRV_Init -Initialize RTC driver This function initializes the RTC driver based on the configuration given by 
                user.
   - rtcTimer1_RTC_DRV_Deinit -Deinitializes RTC driver This function will stop the RTC counter and will disable the interrupts.
   - rtcTimer1_RTC_DRV_GetDefaultConfig -Gets the default configuration for the RTC This function will save the default RTC 
                configuration in the structure passed by the user.
   - rtcTimer1_RTC_DRV_StartCounter -Start the RTC counter This function will start the counter if it was disabled. It will 
                return STATUS_ERROR if the counter was already enabled. Otherwise it will return STATUS_SUCCESS.
   - rtcTimer1_RTC_DRV_StopCounter -Stop the RTC counter This function will stop the counter if it was enabled. It will return 
                STATUS_ERROR if the counter is already disabled. Otherwise it will return STATUS_SUCCESS.
   - rtcTimer1_RTC_DRV_SetTimeDate -Set the time and date This function will set the date passed by the user. It will return 
                STATUS_ERROR if the time and date are invalid. Otherwise it will return STATUS_SUCCESS.
   - rtcTimer1_RTC_DRV_GetTimeDate -Get the time and date This function will get the current time and date and it will store in 
                the structure passed by the user.
   - rtcTimer1_RTC_DRV_UpdateModuleFrequency -Update internal state frequency from the one in hardware This function will 
                update the ticks number that are passed in a second based on the frequency retrieved from Clock Manager and 
                module configuration. This function needs to be called when the system clocks or power mode are changed. After 
                calling this function both alarm and periodic interrupts need to be reconfigured.
   - rtcTimer1_RTC_DRV_GetInterruptFlag -Get interrupt flag This function will get the passed flag status.
   - rtcTimer1_RTC_DRV_ClearInterruptFlag -Clear interrupt flag This function will clear the selected interrupt flag.
   - rtcTimer1_RTC_DRV_GetStatusFlag -Get status flag This function will get the passed flag status.
   - rtcTimer1_RTC_DRV_ConfigureAlarm -Configure the alarm This function will configure the alarm based on the configuration 
                structure passed by the user. It will return STATUS_ERROR if the alarm time configured is invalid, if the time 
                and date are not in future or if the register was not synchronized. Otherwise it will return STATUS_SUCCESS.
   - rtcTimer1_RTC_DRV_ConfigurePeriodicInterrupt -Configure the periodic interrupt This function will configure a periodic 
                interrupt(using the RTC's API functionality) with the period configured by the user. It will calculate the 
                necessary compare value using periodInMs parameter and the clock source of the module. If the calculated value 
                is computed correctly it will return STATUS_SUCCESS, otherwise it will return STATUS_ERROR and the 
                functionality will not be enabled.
   - rtcTimer1_RTC_DRV_ConfigureComparatorTrigger -Configure the analog comparator trigger period This function will configure 
                the analog comparator trigger period with the period configured by the user. It will calculate the necessary 
                compare value using periodInMs parameter and the clock source of the module. If the calculated value is 
                computed correctly it will return STATUS_SUCCESS, otherwise it will return STATUS_ERROR and the functionality 
                will not be enabled.
   - rtcTimer1_RTC_DRV_ConvertSecondsToTimeDate -Convert seconds to rtc_timedate_t structure.
   - rtcTimer1_RTC_DRV_ConvertTimeDateToSeconds -Convert rtc_timedate_t structure to seconds.
   - rtcTimer1_RTC_DRV_IsYearLeap -Check if the current year is leap.
   - rtcTimer1_RTC_DRV_IsTimeDateCorrectFormat -Check if the date time struct is configured properly.
   - rtcTimer1_RTC_DRV_IRQHandler -This method is the API's Interrupt handler for generic and alarm IRQ. It will handle the 
                alarm processing and calls the user callback if they are not NULL.
   - rtcTimer1_RTC_DRV_IsSyncRTCVAL -Check if the timer is synchronized.

Module "Cpu"       (component MPC5748G_176)
   - Cpu_SystemInit -This method configures the oscillator (PLL) that is part of the microcontroller device. SystemInit is 
                called from startup_device file.
   - Cpu_SystemCoreClockUpdate -SystemCoreClockUpdate evaluates the clock register settings and calculates the current core 
                clock.
   - Cpu_SystemSoftwareReset -This method initiates a software rest of the microcontroller.

===================================================================================
