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

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_SetMuxModeSel -This function configures the pin muxing
   - pin_mux_PINS_DRV_SetPinIntSel -This function configures the port pin interrupt/DMA request
   - pin_mux_PINS_DRV_GetPinIntSel -This function gets the current port pin interrupt/DMA request configuration
   - pin_mux_PINS_DRV_ClearPinIntFlagCmd -This function clears the individual pin-interrupt status flag
   - pin_mux_PINS_DRV_EnableDigitalFilter -This function enables digital filter feature for digital pin muxing
   - pin_mux_PINS_DRV_DisableDigitalFilter -This function disables digital filter feature for digital pin muxing
   - pin_mux_PINS_DRV_ConfigDigitalFilter -This function configures digital filter for port with given configuration
   - pin_mux_PINS_DRV_GetPortIntFlag -This function reads the entire port interrupt status flag
   - pin_mux_PINS_DRV_ClearPortIntFlagCmd -This function clears the entire port interrupt status flag
   - pin_mux_PINS_DRV_SetGlobalPinControl -This function quickly configures multiple pins within the one port for the same 
                peripheral function with the same pin configuration
   - pin_mux_PINS_DRV_SetGlobalIntControl -This function quickly configures multiple pins within the one port for the same 
                peripheral function with the same interrupt configuration
   - pin_mux_PINS_DRV_GetPinsDirection -This function returns the current pins directions for a port. Pins corresponding to 
                bits with value of '1' are configured as output and pins corresponding to bits with value of '0' are configured 
                as input.
   - pin_mux_PINS_DRV_SetPinDirection -This function configures the direction for the given pin, with the given value('1' for 
                pin to be configured as output and '0' for pin to be configured as input)
   - pin_mux_PINS_DRV_SetPinsDirection -This function sets the direction configuration for all pins in a port. Pins 
                corresponding to bits with value of '1' will be configured as output and pins corresponding to bits with value 
                of '0' will be configured as input.
   - pin_mux_PINS_DRV_SetPortInputDisable -This function sets the pins input state for a port. Pins corresponding to bits with 
                value of '1' will not be configured as input and pins corresponding to bits with value of '0' will be 
                configured as input
   - pin_mux_PINS_DRV_GetPortInputDisable -This function returns the current pins input state for a port. Pins corresponding to 
                bits with value of '1' are not configured as input and pins corresponding to bits with value of '0' are 
                configured as input
   - 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.
   - clockMan1_CLOCK_DRV_SetModuleClock -Configures the system clocks.
   - clockMan1_CLOCK_DRV_SetSystemClock -Configures the system clocks.
   - clockMan1_CLOCK_DRV_GetSystemClockSource -Gets the system clock source.
   - clockMan1_CLOCK_DRV_SetClockSource -This function configures a clock source.

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_ClearPending -Clear Pending Interrupt.
   - intMan1_INT_SYS_SetPending -Set Pending Interrupt.
   - intMan1_INT_SYS_GetPending -Get Pending Interrupt.
   - intMan1_INT_SYS_GetActive -Get Active Interrupt.

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 "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 "pwrMan1"   (component power_manager)
   - pwrMan1_POWER_SYS_Init -Power manager initialization for operation.
   - pwrMan1_POWER_SYS_Deinit -This function deinitializes the Power manager.
   - pwrMan1_POWER_SYS_SetMode -This function configures the power mode.
   - pwrMan1_POWER_SYS_GetLastMode -This function returns the last successfully set power mode.
   - pwrMan1_POWER_SYS_GetLastModeConfig -This function returns the user configuration structure of the last successfully set 
                power mode.
   - pwrMan1_POWER_SYS_GetCurrentMode -This function returns currently running power mode.
   - pwrMan1_POWER_SYS_GetErrorCallbackIndex -This function returns the last failed notification callback.
   - pwrMan1_POWER_SYS_GetErrorCallback -This function returns the callback configuration structure for the last failed 
                notification.
   - pwrMan1_POWER_SYS_GetDefaultConfig -This function gets the power_manager configuration structure of the default power mode.
   - pwrMan1_POWER_SYS_GetResetSrcStatusCmd -This function gets the current reset source status for specified source.

Module "adConv1"   (component adc)
   - adConv1_ADC_DRV_InitConverterStruct -Initializes the converter configuration structure.
   - adConv1_ADC_DRV_ConfigConverter -Configures the converter with the given configuration structure.
   - adConv1_ADC_DRV_GetConverterConfig -Gets the current converter configuration.
   - adConv1_ADC_DRV_Reset -Resets the converter (sets all configurations to reset values)
   - adConv1_ADC_DRV_InitHwCompareStruct -Initializes the Hardware Compare configuration structure.
   - adConv1_ADC_DRV_ConfigHwCompare -Configures the Hardware Compare feature with the given configuration structure.
   - adConv1_ADC_DRV_GetHwCompareConfig -Gets the current Hardware Compare configuration.
   - adConv1_ADC_DRV_InitHwAverageStruct -Initializes the Hardware Average configuration structure.
   - adConv1_ADC_DRV_ConfigHwAverage -Configures the Hardware Average feature with the given configuration structure.
   - adConv1_ADC_DRV_GetHwAverageConfig -Gets the current Hardware Average configuration.
   - adConv1_ADC_DRV_InitChanStruct -Initializes the control channel configuration structure
   - adConv1_ADC_DRV_ConfigChan -Configures the selected control channel with the given configuration structure
   - adConv1_ADC_DRV_GetChanConfig -Gets the current control channel configuration for the selected channel index
   - adConv1_ADC_DRV_SetSwPretrigger -This function sets the software pretrigger - affects only first 4 control channels.
   - adConv1_ADC_DRV_WaitConvDone -Waits for a conversion/calibration to finish.
   - adConv1_ADC_DRV_GetConvCompleteFlag -Gets the control channel Conversion Complete Flag state
   - adConv1_ADC_DRV_GetChanResult -Gets the last result for the selected control channel
   - adConv1_ADC_DRV_AutoCalibration -Executes an Auto-Calibration.
   - adConv1_ADC_DRV_InitUserCalibrationStruct -Initializes the User Calibration configuration structure.
   - adConv1_ADC_DRV_ConfigUserCalibration -Configures the User Calibration feature with the given configuration structure.
   - adConv1_ADC_DRV_GetUserCalibration -Gets the current User Calibration configuration.
   - adConv1_ADC_DRV_GetInterruptNumber -Returns the interrupt number for the ADC instance.
   - adConv1_ADC_DRV_ClearLatchedTriggers -Clear latched triggers under processing.
   - adConv1_ADC_DRV_ClearTriggerErrors -Clear all latch trigger error.
   - adConv1_ADC_DRV_GetTriggerErrorFlags -This function returns the trigger error flags bits of the ADC instance.

Module "pdb1"      (component pdb)
   - pdb1_PDB_DRV_Init -Initializes the PDB counter and triggers input
   - pdb1_PDB_DRV_Deinit -De-initializes the PDB module
   - pdb1_PDB_DRV_GetDefaultConfig -Gets the default configuration structure of PDB with default settings
   - pdb1_PDB_DRV_Enable -Enables the PDB module
   - pdb1_PDB_DRV_Disable -Disables the PDB module
   - pdb1_PDB_DRV_SoftTriggerCmd -Triggers the PDB with a software trigger
   - pdb1_PDB_DRV_GetTimerValue -Gets the current counter value in the PDB module
   - pdb1_PDB_DRV_GetTimerIntFlag -Gets the PDB interrupt flag
   - pdb1_PDB_DRV_ClearTimerIntFlag -Clears the interrupt flag
   - pdb1_PDB_DRV_LoadValuesCmd -Executes the command of loading values
   - pdb1_PDB_DRV_SetTimerModulusValue -Sets the value of timer modulus
   - pdb1_PDB_DRV_SetValueForTimerInterrupt -Sets the value for the timer interrupt
   - pdb1_PDB_DRV_ConfigAdcPreTrigger -Configures the ADC pre_trigger in the PDB module
   - pdb1_PDB_DRV_GetAdcPreTriggerFlags -Gets the ADC pre_trigger flag in the PDB module
   - pdb1_PDB_DRV_ClearAdcPreTriggerFlags -Clears the ADC pre_trigger flag in the PDB module
   - pdb1_PDB_DRV_GetAdcPreTriggerSeqErrFlags -Gets the ADC pre_trigger flag in the PDB module
   - pdb1_PDB_DRV_ClearAdcPreTriggerSeqErrFlags -Clears the ADC pre_trigger flag in the PDB module
   - pdb1_PDB_DRV_SetAdcPreTriggerDelayValue -Sets the ADC pre_trigger delay value in the PDB module
   - pdb1_PDB_DRV_SetCmpPulseOutEnable -Switches on/off the CMP pulse out in the PDB module
   - pdb1_PDB_DRV_SetCmpPulseOutDelayForHigh -Sets the CMP pulse out delay value for high in the PDB module
   - pdb1_PDB_DRV_SetCmpPulseOutDelayForLow -Sets the CMP pulse out delay value for low in the PDB module

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 channel.
   - dmaController1_EDMA_DRV_ReleaseChannel -Releases an eDMA channel.
   - dmaController1_EDMA_DRV_StartChannel -Starts an eDMA channel.
   - dmaController1_EDMA_DRV_StopChannel -Stops the eDMA channel.
   - dmaController1_EDMA_DRV_InstallCallback -Registers the callback function and the parameter for eDMA channel.
   - dmaController1_EDMA_DRV_GetChannelStatus -Gets the eDMA channel status.
   - dmaController1_EDMA_DRV_PushConfigToReg -Copies the channel configuration to the TCD registers.
   - dmaController1_EDMA_DRV_PushConfigToSTCD -Copies the channel 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 channel's TCD.
   - dmaController1_EDMA_DRV_SetSrcAddr -Configures the source address for the eDMA channel.
   - dmaController1_EDMA_DRV_SetSrcOffset -Configures the source address signed offset for the eDMA channel.
   - 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 channel.
   - dmaController1_EDMA_DRV_SetDestOffset -Configures the destination address signed offset for the eDMA channel.
   - 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 channel.
   - 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 channel interrupt requests.
   - dmaController1_EDMA_DRV_TriggerSwRequest -Triggers a sw request for the current channel.

Module "trgmux1"   (component trgmux)
   - trgmux1_TRGMUX_DRV_Init -Initialize a TRGMUX instance for operation
   - trgmux1_TRGMUX_DRV_Deinit -Reset to default values the source triggers corresponding to all target modules,
   - trgmux1_TRGMUX_DRV_SetTrigSourceForTargetModule -Configure a source trigger for a selected target module
   - trgmux1_TRGMUX_DRV_GetTrigSourceForTargetModule -Get the source trigger configured for a target module
   - trgmux1_TRGMUX_DRV_SetLockForTargetModule -Locks the TRGMUX register of a target module
   - trgmux1_TRGMUX_DRV_GetLockForTargetModule -Get the Lock bit status of the TRGMUX register of a target module
   - trgmux1_TRGMUX_DRV_GenSWTrigger -Generate software trigger

Module "lpit1"     (component lpit)
   - lpit1_LPIT_DRV_GetDefaultConfig -Gets default LPIT module configuration structure
   - lpit1_LPIT_DRV_GetDefaultChanConfig -Gets default timer channel configuration structure
   - lpit1_LPIT_DRV_Init -Initializes the LPIT module.
   - lpit1_LPIT_DRV_Deinit -De-initializes LPIT module.
   - lpit1_LPIT_DRV_InitChannel -Initializes the LPIT channel.
   - lpit1_LPIT_DRV_StartTimerChannels -Starts the timer channel counting.
   - lpit1_LPIT_DRV_StopTimerChannels -Stops the timer channel counting.
   - lpit1_LPIT_DRV_SetTimerPeriodByUs -Sets the timer channel period in microseconds.
   - lpit1_LPIT_DRV_SetTimerPeriodInDual16ModeByUs -Sets the timer channel period in microseconds when the timer channel mode 
                is dual 16 bit periodic counter.
   - lpit1_LPIT_DRV_GetTimerPeriodByUs -Gets the timer channel period in microseconds.
   - lpit1_LPIT_DRV_GetCurrentTimerUs -Gets the current timer channel counting value in microseconds.
   - lpit1_LPIT_DRV_SetTimerPeriodByCount -Sets the timer channel period in count unit.
   - lpit1_LPIT_DRV_SetTimerPeriodInDual16ModeByCount -Sets the timer channel period in count when the timer channel mode is 
                dual 16 bit periodic counter.
   - lpit1_LPIT_DRV_GetTimerPeriodByCount -Gets the current timer channel period in count unit.
   - lpit1_LPIT_DRV_GetCurrentTimerCount -Gets the current timer channel counting value in count.
   - lpit1_LPIT_DRV_EnableTimerChannelInterrupt -Enables the interrupt generation of timer channel.
   - lpit1_LPIT_DRV_DisableTimerChannelInterrupt -Disables the interrupt generation of timer channel.
   - lpit1_LPIT_DRV_GetInterruptFlagTimerChannels -Gets the current interrupt flag of timer channels.
   - lpit1_LPIT_DRV_ClearInterruptFlagTimerChannels -Clears the interrupt flag of timer channels.

Module "Cpu"       (component S32K148_144)
   - Cpu_SystemInit -This function disables the watchdog, enables FPU and the power mode protection. SystemInit is called from 
                startup_device file.
   - Cpu_SystemCoreClockUpdate -SystemCoreClockUpdate evaluates the clock register settings and calculates the current core 
                clock. It must be called whenever the core clock is changed during program execution
   - Cpu_SystemSoftwareReset -This method initiates initiate a system reset.

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