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

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_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_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_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 "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.

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