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

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_SYS_Init -Install pre-defined clock configurations.
   - clockMan1_CLOCK_SYS_UpdateConfiguration -Set system clock configuration according to pre-defined structure.
   - clockMan1_CLOCK_SYS_SetConfiguration -Set system clock configuration.
   - clockMan1_CLOCK_SYS_GetCurrentConfiguration -Get current system clock configuration.
   - clockMan1_CLOCK_SYS_GetErrorCallback -Get the callback which returns error in last clock switch.
   - clockMan1_CLOCK_SYS_GetFreq -Gets the clock frequency for a specific clock name.
   - 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 "lpuart1"   (component lpuart)
   - lpuart1_LPUART_DRV_Init -Initializes an LPUART operation instance.
   - lpuart1_LPUART_DRV_Deinit -Shuts down the LPUART by disabling interrupts and transmitter/receiver.
   - lpuart1_LPUART_DRV_InstallRxCallback -Installs callback function for the LPUART receive.
   - lpuart1_LPUART_DRV_InstallTxCallback -Installs callback function for the LPUART transmit.
   - lpuart1_LPUART_DRV_SendDataBlocking -Sends data out through the LPUART module using a blocking method.
   - lpuart1_LPUART_DRV_SendDataPolling -Send out multiple bytes of data using polling method.
   - lpuart1_LPUART_DRV_SendData -Sends data out through the LPUART module using a non-blocking method. This enables an a-sync 
                method for transmitting data. When used with a non-blocking receive, the LPUART 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.
   - lpuart1_LPUART_DRV_GetTransmitStatus -Returns whether the previous transmit is complete.
   - lpuart1_LPUART_DRV_AbortSendingData -Terminates a non-blocking transmission early.
   - lpuart1_LPUART_DRV_ReceiveDataBlocking -Gets data from the LPUART module by using a blocking method. Blocking means that 
                the function does not return until the receive is complete.
   - lpuart1_LPUART_DRV_ReceiveDataPolling -Receive multiple bytes of data using polling method.
   - lpuart1_LPUART_DRV_ReceiveData -Gets data from the LPUART module by using a non-blocking method. This enables an a-sync 
                method for receiving data. When used with a non-blocking transmission, the LPUART 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.
   - lpuart1_LPUART_DRV_GetReceiveStatus -Returns whether the previous receive is complete.
   - lpuart1_LPUART_DRV_AbortReceivingData -Terminates a non-blocking receive early.
   - lpuart1_LPUART_DRV_SetBaudRate -Configures the LPUART baud rate.
   - lpuart1_LPUART_DRV_GetBaudRate -Returns the LPUART baud rate.
   - lpuart1_LPUART_DRV_SetTxBuffer -Sets the internal driver reference to the tx buffer.
   - lpuart1_LPUART_DRV_SetRxBuffer -Sets the internal driver reference to the 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 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_SetChannelRequest -Configures the DMA request 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 "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 "i2c1"      (component i2c_pal)
   - i2c1_I2C_MasterInit -Initializes the SPI module in master mode.
   - i2c1_I2C_MasterSendData -Initializes a non-blocking master transfer.
   - i2c1_I2C_MasterSendDataBlocking -Initializes a blocking master transfer.
   - i2c1_I2C_MasterReceiveData -Initializes a non-blocking master receive transfer.
   - i2c1_I2C_MasterReceiveDataBlocking -Initializes a blocking master transfer.
   - i2c1_I2C_MasterSetSlaveAddress -Initializes a blocking slave transfer.
   - i2c1_I2C_MasterGetTransferStatus -Return the current status of the I2C master transfer.
   - i2c1_I2C_MasterSetBaudRate -Set the baudrate of the I2C communication.
   - i2c1_I2C_MasterGetBaudRate -Get the baudrate of the I2C communication.
   - i2c1_I2C_MasterAbortTransfer -Abort a non-blocking I2C Master transmission or reception.
   - i2c1_I2C_MasterDeinit -De-initialized the I2C master module
   - i2c1_I2C_GetDefaultMasterConfig -Gets the default configuration structure for master.
   - i2c1_I2C_GetDefaultSlaveConfig -Gets the default configuration structure for slave.
   - i2c1_I2C_SlaveInit -Initializes the i2c slave module.
   - i2c1_I2C_SlaveSendData -Performs a non-blocking send transaction
   - i2c1_I2C_SlaveSendDataBlocking -Performs a blocking send transaction
   - i2c1_I2C_SlaveReceiveData -Performs a non-blocking receive transaction
   - i2c1_I2C_SlaveReceiveDataBlocking -Performs a non-blocking receive transaction
   - i2c1_I2C_SlaveSetRxBuffer -Provide a buffer for receiving data.
   - i2c1_I2C_SlaveSetTxBuffer -Provide a buffer for data to be transferred.
   - i2c1_I2C_SlaveDeinit -De-initializes the i2c slave module.
   - i2c1_I2C_SlaveGetTransferStatus -Return the current status of the I2C slave transfer.
   - i2c1_I2C_SlaveAbortTransfer -Abort a non-blocking I2C Master transmission or reception.

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 "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_pcTimerGetTimerName -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_portSWITCH_TO_USER_MODE -Sets the calling task into User mode. Once in User mode a task cannot return to 
                Privileged mode.
   - 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 S32K148_176)
   - 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.

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