AUTOSAR Classic AUTOSAR-Bibliotheken

Stateless AUTOSAR utility, safety, bit, interpolation, and math libraries: Crc, E2E, Bfx, Bmc, Efx, Ifl, Ifx, Mfl, Mfx, and Msf.

Themenkarte

Crc

Crc_CalculateCRC16 Crc_CalculateCRC16ARC Crc_CalculateCRC32 Crc_CalculateCRC32P4 Crc_CalculateCRC64 Crc_CalculateCRC8 Crc_CalculateCRC8H2F Crc_GetVersionInfo

E2E

176

Efx

124

Ifl

Ifl_DPSearch_f32 Ifl_GetVersionInfo Ifl_Interpolate_f32 Ifl_IntIpoCur_f32_f32 Ifl_IntIpoMap_f32f32_f32 Ifl_IpoCub_f32 Ifl_IpoCub_InTypeMn_f32 Ifl_IpoCur_f32 Ifl_IpoCur_InTypeMn_f32 Ifl_IpoMap_f32 Ifl_IpoMap_InTypeMn_f32 Ifl_DPResultF32_Type

Mfl

112

Mfl Mfl_Abs_f32 Mfl_arcCos_f32 Mfl_ArcCos_f32 Mfl_arcSin_f32 Mfl_ArcSin_f32 Mfl_arcTan2_f32 Mfl_ArcTan2_f32 Mfl_arcTan_f32 Mfl_ArcTan_f32 Mfl_ArrayAverage_f32_f32 Mfl_Average_f32_f32 Mfl_Bitpat_f32_u32 Mfl_CalcTeQ_f32 Mfl_CalcTeQApp_f32 Mfl_Ceil_f32 Mfl_Cos_f32 Mfl_Cos_s32_f32 Mfl_CtrlSetLimit Mfl_CtrlSetLimits Mfl_Cvrt_f32_OutTypeMn Mfl_Cvrt_InTypeMn_f32 Mfl_DeadTime_f32_f32 Mfl_Debounce_u8_u8 Mfl_DebounceInit Mfl_DebounceSetparam Mfl_DebounceSetParam Mfl_DT1Typ1Calc Mfl_DT1Typ1Out_f32 Mfl_DT1Typ1SetState Mfl_DT1Typ2Calc Mfl_DT1Typ2Out_f32 Mfl_DT1Typ2SetState Mfl_Exp_f32 Mfl_Floor_f32 Mfl_GetVersionInfo Mfl_Hypot_f32f32_f32 Mfl_HystCenterHalfDelta_f32_u8 Mfl_HystDeltaRight_f32_u8 Mfl_HystLeftDelta_f32_u8 Mfl_HystLeftRight_f32_u8 Mfl_ICalc Mfl_ILimCalc Mfl_IntToFloatCvrt_InTypeMn_f32 Mfl_IOut_f32 Mfl_ISetState Mfl_Limit_f32 Mfl_Log_f32 Mfl_Max_f32 Mfl_MedianSort_f32_f32 Mfl_Min_f32 Mfl_PCalc Mfl_PDCalc Mfl_PDOut_f32 Mfl_PDSetParam Mfl_PDSetState Mfl_PIDOut_f32 Mfl_PIDSetParam Mfl_PIDSetState Mfl_PIDTyp1Calc Mfl_PIDTyp1LimCalc Mfl_PIDTyp2Calc Mfl_PIDTyp2LimCalc Mfl_PIOut_f32 Mfl_PISetParam Mfl_PISetState Mfl_PITyp1Calc Mfl_PITyp1LimCalc Mfl_PITyp2Calc Mfl_PITyp2LimCalc Mfl_POut_f32 Mfl_Pow_f32 Mfl_PT1Calc Mfl_PT1Out_f32 Mfl_PT1SetState Mfl_PT1Typ1Calc Mfl_RampCalc Mfl_RampCalcJump Mfl_RampCalcSwitch Mfl_RampCalcSwitch_f32 Mfl_RampCheckActivity Mfl_RampGetSwitchPos Mfl_RampInitState Mfl_RampOut_f32 Mfl_RampSetParam Mfl_RateLimiter_f32 Mfl_Round_f32 Mfl_RSqrt_f32 Mfl_Sign_f32 Mfl_Sin_f32 Mfl_Sin_s32_f32 Mfl_SortAscend_f32 Mfl_SortDescend_f32 Mfl_Sqrt_f32 Mfl_Tan_f32 Mfl_Trunc_f32 Mfl_DeadTimeParam_Type Mfl_DebounceParam_Type Mfl_DebounceState_Type Mfl_Limits_Type Mfl_ParamPD_Type Mfl_ParamPI_Type Mfl_ParamPID_Type Mfl_ParamRamp_Type Mfl_StateDT1Typ1_Type Mfl_StateDT1Typ2_Type Mfl_StateI_Type Mfl_StatePD_Type Mfl_StatePI_Type Mfl_StatePID_Type Mfl_StatePT1_Type Mfl_StateRamp_Type

Mfx

Detailansicht

Wähle in der Gliederung einen Eintrag aus.

Für dieses Release liegen keine Elementdaten vor

Bfx

Bfx_ClrBit_TypeMnu8 function

This function shall clear the logical status of the input data to '0' at the requested bit position.

void Bfx_ClrBit_<TypeMn>u8(<Type>* Data, uint8 BitPn); ⚠️

Bfx_ClrBitMask_TypeMnTypeMn function

This function shall clear the logical status to '0' for the input data for all the bit positions as per the mask.

void Bfx_ClrBitMask_<TypeMn><TypeMn>(<Type>* Data, <Type> Mask); ⚠️

Bfx_CopyBit_TypeMnu8TypeMnu8 function

This function shall copy a bit from source data from bit position to destination data at bit position.

void Bfx_CopyBit_<TypeMn>u8<TypeMn>u8(<Type>* DestinationData, uint8 DestinationPosition, <Type> SourceData, uint8 SourcePosition); ⚠️

Bfx_CountLeadingOnes_TypeMn function

Count the number of consecutive ones in Data starting with the most significant bit and return the result.

uint8 Bfx_CountLeadingOnes_<TypeMn>(<Type> Data); ⚠️

Bfx_CountLeadingSigns_TypeMn function

Count the number of consecutive bits which have the same value as most significant bit in Data, starting with bit at position msb minus one. Put the result in Data. It is the number of leading sign bits minus one, giving the number of redundant sign bits in Data.

uint8 Bfx_CountLeadingSigns_<TypeMn>(<Type> Data); ⚠️

Bfx_CountLeadingZeros_TypeMn function

Count the number of consecutive zeros in Data starting with the most significant bit and return the result.

uint8 Bfx_CountLeadingZeros_<TypeMn>(<Type> Data); ⚠️

Bfx_GetBit_InTypeMnu8_u8 function

This function shall return the logical status of the input data for the requested bit position.

boolean Bfx_GetBit_<InTypeMn>u8_u8(<InType> Data, uint8 BitPn);

Bfx_GetBits_TypeMnu8u8_TypeMn function

This function shall return the Bits of the input data starting from 'BitStartPn' for the length of 'Bit Ln'.

<Type> Bfx_GetBits_<TypeMn>u8u8_<TypeMn>(<Type> Data, uint8 BitStartPn, uint8 BitLn); ⚠️

Bfx_GetVersionInfo function

Returns the version information of this library.

void Bfx_GetVersionInfo(Std_VersionInfoType* Versioninfo);

Bfx_PutBit_TypeMnu8u8 function

This function shall update the bit specified by BitPn of input data as '1' or '0' as per 'Status' value.

void Bfx_PutBit_<TypeMn>u8u8(<Type>* Data, uint8 BitPn, boolean Status); ⚠️

Bfx_PutBits_TypeMnu8u8TypeMn function

This function shall put bits as mentioned in Pattern to the input Data from the specified bit position.

void Bfx_PutBits_<TypeMn>u8u8<TypeMn>(<Type>* Data, uint8 BitStartPn, uint8 BitLn, <Type> Pattern); ⚠️

Bfx_PutBitsMask_TypeMnTypeMnTypeMn function

This function shall put all bits defined in Pattern and for which the corresponding Mask bit is set to 1 in the input Data.

void Bfx_PutBitsMask_<TypeMn><TypeMn><TypeMn>(<Type>* Data, <Type> Pattern, <Type> Mask); ⚠️

Bfx_RotBitLt_TypeMnu8 function

This function shall rotate data to the left by ShiftCnt. The most significant bit is rotated to the least significant bit location for every single bit shift cycle.

void Bfx_RotBitLt_<TypeMn>u8(<Type>* Data, uint8 ShiftCnt); ⚠️

Bfx_RotBitRt_TypeMnu8 function

This function shall rotate data to the right by ShiftCnt. The least significant bit is rotated to the most significant bit location for every single bit shift cycle.

void Bfx_RotBitRt_<TypeMn>u8(<Type>* Data, uint8 ShiftCnt); ⚠️

Bfx_SetBit_TypeMnu8 function

This function shall set the logical status of input data as '1' at the requested bit position.

void Bfx_SetBit_<TypeMn>u8(<Type>* Data, uint8 BitPn); ⚠️

Bfx_SetBitMask_TypeMnTypeMn function

This function shall set the data to logical status '1' as per the corresponding Mask bits when set to value 1 and remaining bits will retain their original values.

void Bfx_SetBitMask_<TypeMn><TypeMn>(<Type>* Data, <Type> Mask); ⚠️

Bfx_SetBits_TypeMnu8u8u8 function

This function shall set the input data as '1' or '0' as per 'Status' value starting from 'BitStartPn' for the length 'BitLn'.

void Bfx_SetBits_<TypeMn>u8u8u8(<Type>* Data, uint8 BitStartPn, uint8 BitLn, uint8 Status); ⚠️

Bfx_ShiftBitLt_TypeMnu8 function

This function shall shift data to the left by ShiftCnt. The least significant bit (right-most bit) is replaced by a '0' bit and the most significant bit (left-most bit) is discarded for every single bit shift cycle.

void Bfx_ShiftBitLt_<TypeMn>u8(<Type>* Data, uint8 ShiftCnt); ⚠️

Bfx_ShiftBitRt_TypeMnu8 function

This function shall shift data to the right by ShiftCnt. The most significant bit (left-most bit) is replaced by a '0' bit and the least significant bit (right-most bit) is discarded for every single bit shift cycle.

void Bfx_ShiftBitRt_<TypeMn>u8(<Type>* Data, uint8 ShiftCnt); ⚠️

Bfx_ShiftBitSat_TypeMns8 function

Arithmetic shift with saturation

<Type> Bfx_ShiftBitSat_<TypeMn>s8(sint8 ShiftCnt, <Type> Data); ⚠️

Bfx_ToggleBitMask_TypeMnTypeMn function

This function toggles the bits of data when the corresponding bit of the mask is enabled and set to 1.

void Bfx_ToggleBitMask_<TypeMn><TypeMn>(<Type>* Data, <Type> Mask); ⚠️

Bfx_ToggleBits_TypeMn function

This function toggles all the bits of data (1's Complement Data).

void Bfx_ToggleBits_<TypeMn>(<Type>* Data); ⚠️

Bfx_TstBitLnMask_InTypeMnInTypeMn_u8 function

This function makes a test on the input data and if at least one bit is set as per the mask, then the function shall return TRUE, otherwise it shall return FALSE.

boolean Bfx_TstBitLnMask_<InTypeMn><InTypeMn>_u8(<InType> Data, <InType> Mask);

Bfx_TstBitMask_InTypeMnInTypeMn_u8 function

This function shall return TRUE, if all bits defined in Mask value are set in the input Data value. In all other cases this function shall return FALSE.

boolean Bfx_TstBitMask_<InTypeMn><InTypeMn>_u8(<InType> Data, <InType> Mask);

Bfx_TstParityEven_InTypeMn_u8 function

This function tests the number of bits set to 1. If this number is even, it shall return TRUE, otherwise it returns FALSE.

boolean Bfx_TstParityEven_<InTypeMn>_u8(<InTypeMn> Data);

Bmc

Bmc_CompareExchange_s function

Atomically compares the value pointed to by Object for equality with that in Expected, and if true, replaces the value pointed to by Object with Desired, and if false, updates the value in Expected with the value pointed to by Object.

boolean Bmc_CompareExchange_s(volatile Bmc_AtomicSType* Object, Bmc_AtomicSType* Expected, Bmc_AtomicSType Desired);

Bmc_CompareExchange_TypeMn function

boolean Bmc_CompareExchange_<TypeMn>(volatile <Type>* Object, <Type>* Expected, <Type> Desired); ⚠️

Bmc_CompareExchange_u function

boolean Bmc_CompareExchange_u(volatile Bmc_AtomicUType* Object, Bmc_AtomicUType* Expected, Bmc_AtomicUType Desired);

Bmc_Exchange_s function

Atomically replaces the value pointed to by Object with the value of Desired and returns the value pointed to by Object immediately before the effects.

Bmc_AtomicSType Bmc_Exchange_s(const volatile Bmc_AtomicSType* Object, Bmc_AtomicSType Desired);

Bmc_Exchange_TypeMn function

Atomically replaces the value pointed to by Object with the value of Desired and returns the value pointed to by Object immediately before the effects.

<Type> Bmc_Exchange_<TypeMn>(const volatile <Type>* Object, <Type> Desired); ⚠️

Bmc_Exchange_u function

Atomically replaces the value pointed to by Object with the value of Desired and returns the value pointed to by Object immediately before the effects.

Bmc_AtomicUType Bmc_Exchange_u(const volatile Bmc_AtomicUType* Object, Bmc_AtomicUType Desired);

Bmc_FetchAdd_s function

Atomically replaces the value pointed to by Object with the result of the addition applied to the value pointed to by Object and the given Operand.

Bmc_AtomicSType Bmc_FetchAdd_s(volatile Bmc_AtomicSType* Object, Bmc_AtomicSType Operand);

Bmc_FetchAdd_TypeMn function

Atomically replaces the value pointed to by Object with the result of the addition applied to the value pointed to by Object and the given Operand.

<Type> Bmc_FetchAdd_<TypeMn>(volatile <Type>* Object, <Type> Operand); ⚠️

Bmc_FetchAdd_u function

Atomically replaces the value pointed to by Object with the result of the addition applied to the value pointed to by Object and the given Operand.

Bmc_AtomicUType Bmc_FetchAdd_u(volatile Bmc_AtomicUType* Object, Bmc_AtomicUType Operand);

Bmc_FetchAnd_s function

Atomically replaces the value pointed to by Object with the result of the and-operation applied to the value pointed to by Object and the given Operand.

Bmc_AtomicSType Bmc_FetchAnd_s(volatile Bmc_AtomicSType* Object, Bmc_AtomicSType Operand);

Bmc_FetchAnd_TypeMn function

Atomically replaces the value pointed to by Object with the result of the and-operation applied to the value pointed to by Object and the given Operand.

<Type> Bmc_FetchAnd_<TypeMn>(volatile <Type>* Object, <Type> Operand); ⚠️

Bmc_FetchAnd_u function

Atomically replaces the value pointed to by Object with the result of the and-operation applied to the value pointed to by Object and the given Operand.

Bmc_AtomicUType Bmc_FetchAnd_u(volatile Bmc_AtomicUType* Object, Bmc_AtomicUType Operand);

Bmc_FetchOr_s function

Atomically replaces the value pointed to by Object with the result of the or-operation applied to the value pointed to by Object and the given Operand.

Bmc_AtomicSType Bmc_FetchOr_s(volatile Bmc_AtomicSType* Object, Bmc_AtomicSType Operand);

Bmc_FetchOr_TypeMn function

Atomically replaces the value pointed to by Object with the result of the or-operation applied to the value pointed to by Object and the given Operand.

<Type> Bmc_FetchOr_<TypeMn>(volatile <Type>* Object, <Type> Operand); ⚠️

Bmc_FetchOr_u function

Atomically replaces the value pointed to by Object with the result of the or-operation applied to the value pointed to by Object and the given Operand.

Bmc_AtomicUType Bmc_FetchOr_u(volatile Bmc_AtomicUType* Object, Bmc_AtomicUType Operand);

Bmc_FetchSub_s function

Atomically replaces the value pointed to by Object with the result of the subtraction applied to the value pointed to by Object and the given Operand.

Bmc_AtomicSType Bmc_FetchSub_s(volatile Bmc_AtomicSType* Object, Bmc_AtomicSType Operand);

Bmc_FetchSub_TypeMn function

Atomically replaces the value pointed to by Object with the result of the subtraction applied to the value pointed to by Object and the given Operand.

<Type> Bmc_FetchSub_<TypeMn>(volatile <Type>* Object, <Type> Operand); ⚠️

Bmc_FetchSub_u function

Atomically replaces the value pointed to by Object with the result of the subtraction applied to the value pointed to by Object and the given Operand.

Bmc_AtomicUType Bmc_FetchSub_u(volatile Bmc_AtomicUType* Object, Bmc_AtomicUType Operand);

Bmc_FetchXor_s function

Atomically replaces the value pointed to by Object with the result of the xor-operation applied to the value pointed to by Object and the given Operand.

Bmc_AtomicSType Bmc_FetchXor_s(volatile Bmc_AtomicSType* Object, Bmc_AtomicSType Operand);

Bmc_FetchXor_TypeMn function

Atomically replaces the value pointed to by Object with the result of the xor-operation applied to the value pointed to by Object and the given Operand.

<Type> Bmc_FetchXor_<TypeMn>(volatile <Type>* Object, <Type> Operand); ⚠️

Bmc_FetchXor_u function

Atomically replaces the value pointed to by Object with the result of the xor-operation applied to the value pointed to by Object and the given Operand.

Bmc_AtomicUType Bmc_FetchXor_u(volatile Bmc_AtomicUType* Object, Bmc_AtomicUType Operand);

Bmc_FlagClear function

Atomically sets the value pointed to by Object to false.

void Bmc_FlagClear(volatile Bmc_AtomicFlagType* Object);

Bmc_FlagTestAndSet function

Atomically sets the value pointed to by Object to true.

boolean Bmc_FlagTestAndSet(volatile Bmc_AtomicFlagType* Object);

Bmc_GetVersionInfo function

Returns the version information of this library.

void Bmc_GetVersionInfo(Std_VersionInfoType* Versioninfo);

Bmc_Load_s function

Atomically loads the value pointed to by Object and returns it.

Bmc_AtomicSType Bmc_Load_s(const volatile Bmc_AtomicSType* Object);

Bmc_Load_TypeMn function

Atomically loads the value pointed to by Object and returns it.

<Type> Bmc_Load_<TypeMn>(const volatile <Type>* Object); ⚠️

Bmc_Load_u function

Atomically loads the value pointed to by Object and returns it.

Bmc_AtomicUType Bmc_Load_u(const volatile Bmc_AtomicUType* Object);

Bmc_Store_s function

Atomically replaces the value pointed to by Object with the value of Desired.

void Bmc_Store_s(volatile Bmc_AtomicSType* Object, Bmc_AtomicSType Desired);

Bmc_Store_TypeMn function

Atomically replaces the value pointed to by Object with the value of Desired.

void Bmc_Store_<TypeMn>(volatile <Type>* Object, <Type> Desired); ⚠️

Bmc_Store_u function

Atomically replaces the value pointed to by Object with the value of Desired.

void Bmc_Store_u(volatile Bmc_AtomicUType* Object, Bmc_AtomicUType Desired);

Bmc_ThreadFence function

Creates a sequentially consistent acquire and release fence. An acquire and release fence instruction prevents the memory reordering of any read or write which precedes it in program order with any read or write which follows it in program order.

void Bmc_ThreadFence(void);

Bmc_AtomicFlagType type

The type shall be used for all Flag data items, which are used for Bmc library functions.

Bmc_AtomicSType type

The type shall be used for all signed data items, which are used for Bmc library functions.

Bmc_AtomicUType type

The type shall be used for all unsigned data items, which are used for Bmc library functions.

Crc

Crc_CalculateCRC16 function

This service makes a CRC16 calculation on Crc_Length data bytes.

uint16 Crc_CalculateCRC16(const uint8* Crc_DataPtr, uint32 Crc_Length, uint16 Crc_StartValue16, boolean Crc_IsFirstCall);

Crc_CalculateCRC16ARC function

This service makes a CRC16 calculation on Crc_Length data bytes, using the polynomial 0x8005.

uint16 Crc_CalculateCRC16ARC(const uint8* Crc_DataPtr, uint32 Crc_Length, uint16 Crc_StartValue16, boolean Crc_IsFirstCall);

Crc_CalculateCRC32 function

This service makes a CRC32 calculation on Crc_Length data bytes.

uint32 Crc_CalculateCRC32(const uint8* Crc_DataPtr, uint32 Crc_Length, uint32 Crc_StartValue32, boolean Crc_IsFirstCall);

Crc_CalculateCRC32P4 function

This service makes a CRC32 calculation on Crc_Length data bytes, using the polynomial 0x F4ACFB13. This CRC routine is used by E2E Profile 4.

uint32 Crc_CalculateCRC32P4(const uint8* Crc_DataPtr, uint32 Crc_Length, uint32 Crc_StartValue32, boolean Crc_IsFirstCall);

Crc_CalculateCRC64 function

This service makes a CRC64 calculation on Crc_Length data bytes, using the polynomial 0x42F0E1EBA9EA3693. This CRC routine is used by E2E Profile 7.

uint64 Crc_CalculateCRC64(const uint8* Crc_DataPtr, uint32 Crc_Length, uint64 Crc_StartValue64, boolean Crc_IsFirstCall);

Crc_CalculateCRC8 function

This service makes a CRC8 calculation on Crc_Length data bytes, with SAE J1850 parameters

uint8 Crc_CalculateCRC8(const uint8* Crc_DataPtr, uint32 Crc_Length, uint8 Crc_StartValue8, boolean Crc_IsFirstCall);

Crc_CalculateCRC8H2F function

This service makes a CRC8 calculation with the Polynomial 0x2F on Crc_Length

uint8 Crc_CalculateCRC8H2F(const uint8* Crc_DataPtr, uint32 Crc_Length, uint8 Crc_StartValue8H2F, boolean Crc_IsFirstCall);

Crc_GetVersionInfo function

This service returns the version information of this module.

void Crc_GetVersionInfo(Std_VersionInfoType* Versioninfo);

E2E

E2E_GetVersionInfo function

Returns the version information of this module.

void E2E_GetVersionInfo(Std_VersionInfoType* VersionInfo);

E2E_P01Check function

Checks the Data received using the E2E profile 1. This includes CRC calculation, handling of Counter and Data ID.

Std_ReturnType E2E_P01Check(const E2E_P01ConfigType* Config, E2E_P01CheckStateType* State, const uint8* Data);

E2E_P01CheckInit function

Initializes the check state

Std_ReturnType E2E_P01CheckInit(E2E_P01CheckStateType* StatePtr);

E2E_P01Forward function

Protects data which is forwarded by using the E2E profile 01. This includes checksum calculation, handling of counter and Data ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P01Forward(const E2E_P01ConfigType* ConfigPtr, E2E_PCheckStatusType Checkstatus, E2E_P01ProtectStateType* StatePtr, uint8* DataPtr);

E2E_P01MapStatusToSM function

The function maps the check status of Profile 1 to a generic check status, which can be used by E2E state machine check function. The E2E Profile 1 delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P01MapStatusToSM(Std_ReturnType CheckReturn, E2E_P01CheckStatusType Status, boolean profileBehavior);

E2E_P01Protect function

Protects the array/buffer to be transmitted using the E2E profile 1. This includes checksum calculation, handling of counter and Data ID.

Std_ReturnType E2E_P01Protect(const E2E_P01ConfigType* ConfigPtr, E2E_P01ProtectStateType* StatePtr, uint8* DataPtr);

E2E_P01ProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P01ProtectInit(E2E_P01ProtectStateType* StatePtr);

E2E_P02Check function

Check the array/buffer using the E2E profile 2. This includes checksum calculation, handling of sequence counter and Data ID.

Std_ReturnType E2E_P02Check(const E2E_P02ConfigType* ConfigPtr, E2E_P02CheckStateType* StatePtr, const uint8* DataPtr);

E2E_P02CheckInit function

Initializes the check state

Std_ReturnType E2E_P02CheckInit(E2E_P02CheckStateType* StatePtr);

E2E_P02Forward function

Protects data which is forwarded by using the E2E profile 02. This includes checksum calculation, handling of counter and Data ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P02Forward(const E2E_P02ConfigType* ConfigPtr, E2E_PCheckStatusType Checkstatus, E2E_P02ProtectStateType* StatePtr, uint8* DataPtr);

E2E_P02MapStatusToSM function

The function maps the check status of Profile 2 to a generic check status, which can be used by E2E state machine check function. The E2E Profile 2 delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P02MapStatusToSM(Std_ReturnType CheckReturn, E2E_P02CheckStatusType Status, boolean profileBehavior);

E2E_P02Protect function

Protects the array/buffer to be transmitted using the E2E profile 2. This includes checksum calculation, handling of sequence counter and Data ID.

Std_ReturnType E2E_P02Protect(const E2E_P02ConfigType* ConfigPtr, E2E_P02ProtectStateType* StatePtr, uint8* DataPtr);

E2E_P02ProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P02ProtectInit(E2E_P02ProtectStateType* StatePtr);

E2E_P04Check function

Checks the Data received using the E2E profile 4. This includes CRC calculation, handling of Counter and Data ID. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link.

Std_ReturnType E2E_P04Check(const E2E_P04ConfigType* ConfigPtr, E2E_P04CheckStateType* StatePtr, const uint8* DataPtr, uint16 Length);

E2E_P04CheckInit function

Initializes the check state

Std_ReturnType E2E_P04CheckInit(E2E_P04CheckStateType* StatePtr);

E2E_P04Forward function

Protects data which is forwarded by using the E2E profile 04. This includes checksum calculation, handling of counter and Data ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P04Forward(const E2E_P04ConfigType* ConfigPtr, uint16 Length, E2E_PCheckStatusType Checkstatus, E2E_P04ProtectStateType StatePtr, uint8* DataPtr);

E2E_P04GetHeaderInfo function

Retrieves header element data for further processing when using the E2E profile 04. This includes the SequenceCounter.

Std_ReturnType E2E_P04GetHeaderInfo(const E2E_P04ConfigType* ConfigPtr, const uint8* DataPtr, uint16 Length, E2E_P04HeaderInformationType* HeaderInfoPtr);

E2E_P04MapStatusToSM function

The function maps the check status of Profile 4 to a generic check status, which can be used by E2E state machine check function. The E2E Profile 4 delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P04MapStatusToSM(Std_ReturnType CheckReturn, E2E_P04CheckStatusType Status);

E2E_P04mCheckInit function

Initializes the check state

Std_ReturnType E2E_P04mCheckInit(E2E_P04mCheckStateType* StatePtr);

E2E_P04mForward function

Protects data which is forwarded by using the E2E profile 4m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P04mForward(const E2E_P04mConfigType* ConfigPtr, uint16 Length, E2E_PCheckStatusType Checkstatus, E2E_P04mProtectStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType MessageResult, uint8* DataPtr);

E2E_P04mGetHeaderInfo function

Retrieves header element data for further processing when using the E2E profile 04m. This includes SequenceCounter and SourceID.

Std_ReturnType E2E_P04mGetHeaderInfo(const E2E_P04mConfigType* ConfigPtr, const uint8* DataPtr, uint16 Length, E2E_P04mHeaderInformationType* HeaderInfoPtr);

E2E_P04mMapStatusToSM function

The function maps the check status of Profile 4m to a generic check status, which can be used by E2E state machine check function. The E2E Profile 4m delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P04mMapStatusToSM(Std_ReturnType CheckReturn, E2E_P04mCheckStatusType Status);

E2E_P04mProtect function

Protects the array/buffer to be transmitted using the E2E profile 4m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID.

Std_ReturnType E2E_P04mProtect(const E2E_P04mConfigType* ConfigPtr, E2E_P04mProtectStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType MessageResult, uint8* DataPtr, uint16 Length);

E2E_P04mProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P04mProtectInit(E2E_P04mProtectStateType* StatePtr);

E2E_P04mSinkCheck function

Checks the Data received using the E2E profile 4m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link. This function is intended for usage at the data sink (i.e., in case of C/S communication at the server).

Std_ReturnType E2E_P04mSinkCheck(const E2E_P04mConfigType* ConfigPtr, E2E_P04mCheckStateType StatePtr, uint32* SourceID, Std_MessageTypeType MessageType, Std_MessageResultType MessageResult, const uint8* DataPtr, uint16 Length);

E2E_P04mSourceCheck function

Checks the Data received using the E2E profile 4m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link. This function is intended for usage at the data source (i.e., in case of C/S communication at the client).

Std_ReturnType E2E_P04mSourceCheck(const E2E_P04mConfigType* ConfigPtr, E2E_P04mCheckStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType MessageResult, const uint8* DataPtr, uint16 Length);

E2E_P04Protect function

Protects the array/buffer to be transmitted using the E2E profile 4. This includes checksum calculation, handling of counter and Data ID.

Std_ReturnType E2E_P04Protect(const E2E_P04ConfigType* ConfigPtr, E2E_P04ProtectStateType* StatePtr, uint8* DataPtr, uint16 Length);

E2E_P04ProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P04ProtectInit(E2E_P04ProtectStateType* StatePtr);

E2E_P05Check function

Checks the Data received using the E2E profile 5. This includes CRC calculation, handling of Counter. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link.

Std_ReturnType E2E_P05Check(const E2E_P05ConfigType* ConfigPtr, E2E_P05CheckStateType* StatePtr, const uint8* DataPtr, uint16 Length);

E2E_P05CheckInit function

Initializes the check state

Std_ReturnType E2E_P05CheckInit(E2E_P05CheckStateType* StatePtr);

E2E_P05Forward function

Protects data which is forwarded by using the E2E profile 05. This includes checksum calculation, handling of counter and Data ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P05Forward(const E2E_P05ConfigType* ConfigPtr, uint16 Length, E2E_PCheckStatusType Checkstatus, E2E_P05ProtectStateType* StatePtr, uint8* DataPtr);

E2E_P05GetHeaderInfo function

Retrieves header element data for further processing when using the E2E profile 05. This includes the SequenceCounter.

Std_ReturnType E2E_P05GetHeaderInfo(const E2E_P05ConfigType* ConfigPtr, const uint8* DataPtr, uint8 Length, E2E_P05HeaderInformationType* HeaderInfoPtr);

E2E_P05MapStatusToSM function

The function maps the check status of Profile 5 to a generic check status, which can be used by E2E state machine check function. The E2E Profile 5 delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P05MapStatusToSM(Std_ReturnType CheckReturn, E2E_P05CheckStatusType Status);

E2E_P05Protect function

Protects the array/buffer to be transmitted using the E2E profile 5. This includes checksum calculation, handling of counter.

Std_ReturnType E2E_P05Protect(const E2E_P05ConfigType* ConfigPtr, E2E_P05ProtectStateType* StatePtr, uint8* DataPtr, uint16 Length);

E2E_P05ProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P05ProtectInit(E2E_P05ProtectStateType* StatePtr);

E2E_P06Check function

Checks the Data received using the E2E profile 6. This includes CRC calculation, handling of Counter. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link.

Std_ReturnType E2E_P06Check(const E2E_P06ConfigType* ConfigPtr, E2E_P06CheckStateType* StatePtr, const uint8* DataPtr, uint16 Length);

E2E_P06CheckInit function

Initializes the check state

Std_ReturnType E2E_P06CheckInit(E2E_P06CheckStateType* StatePtr);

E2E_P06Forward function

Protects data which is forwarded by using the E2E profile 06. This includes checksum calculation, handling of counter and Data ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P06Forward(const E2E_P06ConfigType* ConfigPtr, uint16 Length, E2E_PCheckStatusType Checkstatus, E2E_P06ProtectStateType* StatePtr, uint8* DataPtr);

E2E_P06GetHeaderInfo function

Retrieves header element data for further processing when using the E2E profile 06. This includes the SequenceCounter.

Std_ReturnType E2E_P06GetHeaderInfo(const E2E_P06ConfigType* ConfigPtr, const uint8* DataPtr, uint8 Length, E2E_P06HeaderInformationType* HeaderInfoPtr);

E2E_P06MapStatusToSM function

The function maps the check status of Profile 6 to a generic check status, which can be used by E2E state machine check function. The E2E Profile 6 delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P06MapStatusToSM(Std_ReturnType CheckReturn, E2E_P06CheckStatusType Status);

E2E_P06Protect function

Protects the array/buffer to be transmitted using the E2E profile 6. This includes checksum calculation, handling of counter.

Std_ReturnType E2E_P06Protect(const E2E_P06ConfigType* ConfigPtr, E2E_P06ProtectStateType* StatePtr, uint8* DataPtr, uint16 Length);

E2E_P06ProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P06ProtectInit(E2E_P06ProtectStateType* StatePtr);

E2E_P07Check function

Checks the Data received using the E2E profile 7. This includes CRC calculation, handling of Counter and Data ID. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link.

Std_ReturnType E2E_P07Check(const E2E_P07ConfigType* ConfigPtr, E2E_P07CheckStateType* StatePtr, const uint8* DataPtr, uint32 Length);

E2E_P07CheckInit function

Initializes the check state

Std_ReturnType E2E_P07CheckInit(E2E_P07CheckStateType* StatePtr);

E2E_P07Forward function

Protects data which is forwarded by using the E2E profile 07. This includes checksum calculation, handling of counter and Data ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P07Forward(E2E_P07ConfigType* ConfigPtr, uint32 Length, E2E_PCheckStatusType Checkstatus, E2E_P07ProtectStateType* StatePtr, uint8* DataPtr);

E2E_P07GetHeaderInfo function

Retrieves header element data for further processing when using the E2E profile 07. This includes the SequenceCounter

Std_ReturnType E2E_P07GetHeaderInfo(const E2E_P07ConfigType* ConfigPtr, const uint8* DataPtr, uint32 Length, E2E_P07HeaderInformationType* HeaderInfoPtr);

E2E_P07MapStatusToSM function

The function maps the check status of Profile 7 to a generic check status, which can be used by E2E state machine check function. The E2E Profile 7 delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P07MapStatusToSM(E2E_PCheckStatusType return, E2E_P07CheckStatusType Status);

E2E_P07mCheckInit function

Initializes the check state

Std_ReturnType E2E_P07mCheckInit(E2E_P07mCheckStateType* StatePtr);

E2E_P07mForward function

Protects data which is forwarded by using the E2E profile 7m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P07mForward(const E2E_P07mConfigType* ConfigPtr, uint32 Length, E2E_PCheckStatusType Checkstatus, E2E_P07mProtectStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType MessageResult, uint8* DataPtr);

E2E_P07mGetHeaderInfo function

Retrieves header element data for further processing when using the E2E profile 07m. This includes SequenceCounter and SourceID.

Std_ReturnType E2E_P07mGetHeaderInfo(const E2E_P07mConfigType* ConfigPtr, const uint8* DataPtr, uint32 Length, E2E_P07mHeaderInformationType* HeaderInfoPtr);

E2E_P07mMapStatusToSM function

The function maps the check status of Profile 7m to a generic check status, which can be used by E2E state machine check function. The E2E Profile 7m delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P07mMapStatusToSM(Std_ReturnType CheckReturn, E2E_P07mCheckStatusType Status);

E2E_P07mProtect function

Protects the array/buffer to be transmitted using the E2E profile 7m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID.

Std_ReturnType E2E_P07mProtect(const E2E_P07mConfigType* ConfigPtr, E2E_P07mProtectStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType MessageResult, uint8* DataPtr, uint32 Length);

E2E_P07mProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P07mProtectInit(E2E_P07mProtectStateType* StatePtr);

E2E_P07mSinkCheck function

Checks the Data received using the E2E profile 7m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link. This function is intended for usage at the data sink (i.e., in case of C/S communication at the server).

Std_ReturnType E2E_P07mSinkCheck(const E2E_P07mConfigType* ConfigPtr, E2E_P07mCheckStateType* StatePtr, uint32* SourceID, Std_MessageTypeType MessageType, Std_MessageResultType MessageResult, const uint8* DataPtr, uint32 Length);

E2E_P07mSourceCheck function

Checks the Data received using the E2E profile 7m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link. This function is intended for usage at the data source (i.e., in case of C/S communication at the client).

Std_ReturnType E2E_P07mSourceCheck(const E2E_P07mConfigType* ConfigPtr, E2E_P07mCheckStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType MessageResult, const uint8* DataPtr, uint32 Length);

E2E_P07Protect function

Protects the array/buffer to be transmitted using the E2E profile 7. This includes checksum calculation, handling of counter and Data ID.

Std_ReturnType E2E_P07Protect(const E2E_P07ConfigType* ConfigPtr, E2E_P07ProtectStateType* StatePtr, uint8* DataPtr, uint32 Length);

E2E_P07ProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P07ProtectInit(E2E_P07ProtectStateType* StatePtr);

E2E_P08Check function

Checks the Data received using the E2E profile 08. This includes CRC calculation, handling of Counter and Data ID. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link.

Std_ReturnType E2E_P08Check(const E2E_P08ConfigType* ConfigPtr, E2E_P08CheckStateType* StatePtr, const uint8* DataPtr, uint32 Length);

E2E_P08CheckInit function

Initializes the check state

Std_ReturnType E2E_P08CheckInit(E2E_P08CheckStateType* StatePtr);

E2E_P08Forward function

Protects data which is forwarded by using the E2E profile 08. This includes checksum calculation, handling of counter and Data ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P08Forward(const E2E_P08ConfigType* ConfigPtr, uint32 Length, E2E_PCheckStatusType Checkstatus, E2E_P08ProtectStateType StatePtr, uint8* DataPtr);

E2E_P08GetHeaderInfo function

Retrieves header element data for further processing when using the E2E profile 08. This includes the SequenceCounter

Std_ReturnType E2E_P08GetHeaderInfo(const E2E_P08ConfigType* ConfigPtr, const uint8* DataPtr, uint32 Length, E2E_P08HeaderInformationType* HeaderInfoPtr);

E2E_P08MapStatusToSM function

The function maps the check status of Profile 08 to a generic check status, which can be used by E2E state machine check function. The E2E Profile 08 delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P08MapStatusToSM(Std_ReturnType CheckReturn, E2E_P08CheckStatusType Status);

E2E_P08mCheckInit function

Initializes the check state

Std_ReturnType E2E_P08mCheckInit(E2E_P08mCheckStateType* StatePtr);

E2E_P08mForward function

Protects data which is forwarded by using the E2E profile 08m. This includes checksum calculation, handling of counter and Data ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P08mForward(const E2E_P08mConfigType* ConfigPtr, uint32 Length, E2E_PCheckStatusType Checkstatus, E2E_P08mProtectStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType Messageresult, uint8* DataPtr);

E2E_P08mGetHeaderInfo function

Retrieves header element data for further processing when using the E2E profile 08m. This includes SequenceCounter and SourceID.

Std_ReturnType E2E_P08mGetHeaderInfo(const E2E_P08mConfigType* ConfigPtr, const uint8* DataPtr, uint32 Length, E2E_P08mHeaderInformationType* HeaderInfoPtr);

E2E_P08mMapStatusToSM function

The function maps the check status of Profile 08m to a generic check status, which can be used by E2E state machine check function. The E2E Profile 08m delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P08mMapStatusToSM(Std_ReturnType CheckReturn, E2E_P08mCheckStatusType Status);

E2E_P08mProtect function

Protects the array/buffer to be transmitted using the E2E profile 08m. This includes CRC calculation, handling of counter, Data ID, Message Type, Message Result and Source ID.

Std_ReturnType E2E_P08mProtect(const E2E_P08mConfigType* ConfigPtr, E2E_P08mProtectStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType Messageresult, uint8* DataPtr, uint32 Length);

E2E_P08mProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P08mProtectInit(E2E_P08mProtectStateType* StatePtr);

E2E_P08mSinkCheck function

Checks the Data received using the E2E profile 8m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link. This function is intended for usage at the data sink (i.e., in case of C/S communication at the server).

Std_ReturnType E2E_P08mSinkCheck(const E2E_P08mConfigType* ConfigPtr, E2E_P08mCheckStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType Messageresult, const uint8* DataPtr, uint32 Length);

E2E_P08mSourceCheck function

Checks the Data received using the E2E profile 8m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link. This function is intended for usage at the data source (i.e., in case of C/S communication at the client).

Std_ReturnType E2E_P08mSourceCheck(const E2E_P08mConfigType* ConfigPtr, E2E_P08mCheckStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType Messageresult, const uint8* DataPtr, uint32 Length);

E2E_P08Protect function

Protects the array/buffer to be transmitted using the E2E profile 08. This includes checksum calculation, handling of counter and Data ID.

Std_ReturnType E2E_P08Protect(const E2E_P08ConfigType* ConfigPtr, E2E_P08ProtectStateType* StatePtr, uint8* DataPtr, uint32 Length);

E2E_P08ProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P08ProtectInit(E2E_P08ProtectStateType* StatePtr);

E2E_P11Check function

Checks the Data received using the E2E profile 11. This includes CRC calculation, handling of Counter. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link.

Std_ReturnType E2E_P11Check(const E2E_P11ConfigType* ConfigPtr, E2E_P11CheckStateType* StatePtr, const uint8* DataPtr);

E2E_P11CheckInit function

Initializes the check state

Std_ReturnType E2E_P11CheckInit(E2E_P11CheckStateType* StatePtr);

E2E_P11Forward function

Protects data which is forwarded by using the E2E profile 11. This includes checksum calculation, handling of counter and Data ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P11Forward(const E2E_P11ConfigType* ConfigPtr, uint16 Length, E2E_PCheckStatusType Checkstatus, E2E_P11ProtectStateType* StatePtr, uint8* DataPtr);

E2E_P11MapStatusToSM function

The function maps the check status of Profile 11 to a generic check status, which can be used by E2E state machine check function. The E2E Profile 11 delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P11MapStatusToSM(Std_ReturnType CheckReturn, E2E_P11CheckStatusType Status);

E2E_P11Protect function

Protects the array/buffer to be transmitted using the E2E profile 11. This includes checksum calculation, handling of counter.

Std_ReturnType E2E_P11Protect(const E2E_P11ConfigType* ConfigPtr, E2E_P11ProtectStateType* StatePtr, uint8* DataPtr, uint16 Length);

E2E_P11ProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P11ProtectInit(E2E_P11ProtectStateType* StatePtr);

E2E_P22Check function

Checks the Data received using the E2E profile 22. This includes CRC calculation, handling of Counter. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link.

Std_ReturnType E2E_P22Check(const E2E_P22ConfigType* ConfigPtr, E2E_P22CheckStateType* StatePtr, const uint8* DataPtr, uint16 Length);

E2E_P22CheckInit function

Initializes the check state

Std_ReturnType E2E_P22CheckInit(E2E_P22CheckStateType* StatePtr);

E2E_P22Forward function

Protects data which is forwarded by using the E2E profile 22. This includes checksum calculation, handling of counter and Data ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P22Forward(E2E_P22ConfigType* ConfigPtr, E2E_PCheckStatusType Checkstatus, E2E_P22ProtectStateType* StatePtr, uint8 DataPtr);

E2E_P22MapStatusToSM function

The function maps the check status of Profile 22 to a generic check status, which can be used by E2E state machine check function. The E2E Profile 22 delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P22MapStatusToSM(Std_ReturnType CheckReturn, E2E_P22CheckStatusType Status);

E2E_P22Protect function

Protects the array/buffer to be transmitted using the E2E profile 22. This includes checksum calculation, handling of counter.

Std_ReturnType E2E_P22Protect(const E2E_P22ConfigType* ConfigPtr, E2E_P22ProtectStateType* StatePtr, uint8* DataPtr, uint16 Length);

E2E_P22ProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P22ProtectInit(E2E_P22ProtectStateType* StatePtr);

E2E_P44Check function

Checks the Data received using the E2E profile 44. This includes CRC calculation, handling of Counter and Data ID. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link.

Std_ReturnType E2E_P44Check(const E2E_P44ConfigType* ConfigPtr, E2E_P44CheckStateType* StatePtr, const uint8* DataPtr, uint16 Length);

E2E_P44CheckInit function

Initializes the check state.

Std_ReturnType E2E_P44CheckInit(E2E_P44CheckStateType* StatePtr);

E2E_P44Forward function

Protects data which is forwarded by using the E2E profile 44. This includes checksum calculation, handling of counter and Data ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P44Forward(const E2E_P44ConfigType* ConfigPtr, uint16 Length, E2E_P44CheckStatusType Checkstatus, E2E_P44ProtectStateType StatePtr, uint8* DataPtr);

E2E_P44GetHeaderInfo function

Retrieves header element data for further processing when using the E2E profile 44. This includes the SequenceCounter

Std_ReturnType E2E_P44GetHeaderInfo(const E2E_P44ConfigType* ConfigPtr, const uint8* DataPtr, uint16 Length, E2E_P44HeaderInformationType* HeaderInfoPtr);

E2E_P44MapStatusToSM function

The function maps the check status of Profile 44 to a generic check status, which can be used by E2E state machine check function. The E2E Profile 44 delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P44MapStatusToSM(Std_ReturnType CheckReturn, E2E_P44CheckStatusType Status);

E2E_P44mCheckInit function

Initializes the check state

Std_ReturnType E2E_P44mCheckInit(E2E_P44mCheckStateType* StatePtr);

E2E_P44mForward function

Protects data which is forwarded by using the E2E profile 44m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID. Detected Errors of received message will be reconstruct on output data. Tags: atp.Status=draft

Std_ReturnType E2E_P44mForward(const E2E_P44mConfigType* ConfigPtr, uint32 Length, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType Messageresult, E2E_P44mProtectStateType* StatePtr, uint8* DataPtr);

E2E_P44mGetHeaderInfo function

Retrieves header element data for further processing when using the E2E profile 44m. This includes SequenceCounter and SourceID.

Std_ReturnType E2E_P44mGetHeaderInfo(const E2E_P44mConfigType* ConfigPtr, const uint8* DataPtr, uint16 Length, E2E_P44mHeaderInformationType* HeaderInfoPtr);

E2E_P44mMapStatusToSM function

The function maps the check status of Profile 44m to a generic check status, which can be used by E2E state machine check function. The E2E Profile 44m delivers a more fine-granular status, but this is not relevant for the E2E state machine.

E2E_PCheckStatusType E2E_P44mMapStatusToSM(Std_ReturnType CheckReturn, E2E_P44mCheckStatusType Status);

E2E_P44mProtect function

Protects the array/buffer to be transmitted using the E2E profile 44m. This includes CRC calculation, handling of counter, Data ID, Message Type, Message Result and Source ID.

Std_ReturnType E2E_P44mProtect(const E2E_P44mConfigType* ConfigPtr, E2E_P44mProtectStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType Messageresult, uint8* DataPtr, uint32 Length);

E2E_P44mProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P44mProtectInit(E2E_P44mProtectStateType* StatePtr);

E2E_P44mSinkCheck function

Checks the Data received using the E2E profile 44m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link. This function is intended for usage at the data sink (i.e., in case of C/S communication at the server).

Std_ReturnType E2E_P44mSinkCheck(const E2E_P44mConfigType* ConfigPtr, E2E_P44mCheckStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType Messageresult, const uint8* DataPtr, uint32 Length);

E2E_P44mSourceCheck function

Checks the Data received using the E2E profile 44m. This includes CRC calculation, handling of Counter, Data ID, Message Type, Message Result, and Source ID. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link. This function is intended for usage at the data source (i.e., in case of C/S communication at the client).

Std_ReturnType E2E_P44mSourceCheck(const E2E_P44mConfigType* ConfigPtr, E2E_P44mCheckStateType* StatePtr, uint32 SourceID, Std_MessageTypeType MessageType, Std_MessageResultType Messageresult, const uint8* DataPtr, uint32 Length);

E2E_P44Protect function

Protects the array/buffer to be transmitted using the E2E profile 44. This includes checksum calculation, handling of counter and Data ID.

Std_ReturnType E2E_P44Protect(const E2E_P44ConfigType* ConfigPtr, E2E_P44ProtectStateType* StatePtr, uint8* DataPtr, uint16 Length);

E2E_P44ProtectInit function

Initializes the protection state.

Std_ReturnType E2E_P44ProtectInit(E2E_P44ProtectStateType* StatePtr);

E2E_P76Check function

Checks the Data received using the E2E profile 76. This includes CRC calculation, handling of Counter. The function checks only one single data in one cycle, it does not determine/compute the accumulated state of the communication link. Tags: atp.Status=draft

Std_ReturnType E2E_P76Check(const E2E_P76ConfigType* ConfigPtr, E2E_P76CheckStateType* StatePtr, const uint8* DataPtr, uint32 Length);

E2E_P76CheckInit function

Initializes the check state Tags: atp.Status=draft

Std_ReturnType E2E_P76CheckInit(E2E_P76CheckStateType* StatePtr);

E2E_P76MapStatusToSM function

The function maps the check status of Profile 76 to a generic check status, which can be used by E2E state machine check function. The E2E Profile 76 delivers a more fine-granular status, but this is not relevant for the E2E state machine. Tags: atp.Status=draft

E2E_PCheckStatusType E2E_P76MapStatusToSM(Std_ReturnType CheckReturn, E2E_P76CheckStatusType Status);

E2E_P76ProtectInit function

Initializes the protection state. Tags: atp.Status=draft

Std_ReturnType E2E_P76ProtectInit(E2E_P76ProtectStateType* StatePtr);

E2E_SMCheck function

Checks the communication channel. It determines if the data can be used for safety-related application, based on history of checks performed by a corresponding E2E_P0XCheck() function.

Std_ReturnType E2E_SMCheck(E2E_PCheckStatusType ProfileStatus, const E2E_SMConfigType* ConfigPtr, E2E_SMCheckStateType* StatePtr);

E2E_SMCheckInit function

Initializes the state machine.

Std_ReturnType E2E_SMCheckInit(E2E_SMCheckStateType* StatePtr, const E2E_SMConfigType* ConfigPtr);

E2EPW_ReadInit1_p_o function

The function reinitializes the corresponding data structure after a detected error or at startup.

uint8 E2EPW_ReadInit1_<p>_<o>(Rte_Instance <instance>);

E2EPW_ReadInit2_p_o function

The function reinitializes the corresponding data structure after a detected error or at startup.

uint8 E2EPW_ReadInit2_<p>_<o>(Rte_Instance <instance>);

E2EPW_WriteInit1_p_o function

The function reinitializes the corresponding data structure after a detected error or at startup.

uint8 E2EPW_WriteInit1_<p>_<o>(Rte_Instance <instance>);

E2EPW_WriteInit2_p_o function

The function reinitializes the corresponding data structure after a detected error or at startup.

uint8 E2EPW_WriteInit2_<p>_<o>(Rte_Instance <instance>);

E2E_P01CheckStateType type

State of the receiver for a Data protected with E2E Profile 1.

E2E_P01CheckStatusType type

Result of the verification of the Data in E2E Profile 1, determined by the Check function.

E2E_P01ConfigType type

Configuration of transmitted Data (Data Element or I-PDU), for E2E Profile 1. For each transmitted Data, there is an instance of this typedef.

E2E_P01DataIDMode type

The Data ID is two bytes long in E2E Profile 1. There are four inclusion modes how the implicit two-byte Data ID is included in the one-byte CRC.

E2E_P01ProtectStateType type

State of the sender for a Data protected with E2E Profile 1.

E2E_P02CheckStateType type

State of the sender for a Data protected with E2E Profile 2.

E2E_P02CheckStatusType type

Result of the verification of the Data in E2E Profile 2, determined by the Check function.

E2E_P02ConfigType type

Non-modifiable configuration of the data element sent over an RTE port, for E2E profile 2. The position of the counter and CRC is not configurable in profile 2.

E2E_P02ProtectStateType type

State of the sender for a Data protected with E2E Profile 2.

E2E_P04CheckStateType type

State of the reception on one single Data protected with E2E Profile 4.

E2E_P04CheckStatusType type

Status of the reception on one single Data in one cycle, protected with E2E Profile 4.

E2E_P04ConfigType type

Configuration of transmitted Data (Data Element or I-PDU), for E2E Profile 4. For each transmitted Data, there is an instance of this typedef.

E2E_P04HeaderInformationType type

Data that can be retrieved from E2E header on receiver side in case E2E Profile 04 is used.

E2E_P04mCheckStateType type

State of the reception on one single Data protected with E2E Profile 4m.

E2E_P04mCheckStatusType type

Status of the reception on one single Data in one cycle, protected with E2E Profile 4m.

E2E_P04mConfigType type

Configuration of transmitted Data (Data Element or I-PDU), for E2E Profile 4m. For each transmitted Data, there is an instance of this typedef.

E2E_P04mProtectStateType type

State of the sender for a Data protected with E2E Profile 4m.

E2E_P04ProtectStateType type

State of the sender for a Data protected with E2E Profile 4.

E2E_P05CheckStateType type

Description: State of the reception on one single Data protected with E2E Profile 5.

E2E_P05CheckStatusType type

Status of the reception on one single Data in one cycle, protected with E2E Profile 5.

E2E_P05ConfigType type

Configuration of transmitted Data (Data Element or I-PDU), for E2E Profile 5. For each transmitted Data, there is an instance of this typedef.

E2E_P05HeaderInformationType type

Data that can be retrieved from E2E header on receiver side in case E2E Profile 05 is used.

E2E_P05ProtectStateType type

State of the sender for a Data protected with E2E Profile 5.

E2E_P06CheckStateType type

State of the reception on one single Data protected with E2E Profile 6.

E2E_P06CheckStatusType type

Status of the reception on one single Data in one cycle, protected with E2E Profile 6.

E2E_P06ConfigType type

Configuration of transmitted Data (Data Element or I-PDU), for E2E Profile 6. For each transmitted Data, there is an instance of this typedef.

E2E_P06HeaderInformationType type

Data that can be retrieved from E2E header on receiver side in case E2E Profile 06 is used.

E2E_P06ProtectStateType type

State of the sender for a Data protected with E2E Profile 6.

E2E_P07CheckStateType type

State of the reception on one single Data protected with E2E Profile 7.

E2E_P07CheckStatusType type

Status of the reception on one single Data in one cycle, protected with E2E Profile 7.

E2E_P07ConfigType type

Configuration of transmitted Data (Data Element or I-PDU), for E2E Profile 7. For each transmitted Data, there is an instance of this typedef.

E2E_P07mCheckStateType type

State of the reception on one single Data protected with E2E Profile 7m.

E2E_P07mCheckStatusType type

Status of the reception on one single Data in one cycle, protected with E2E Profile 7m.

E2E_P07mConfigType type

Configuration of transmitted Data (Data Element or I-PDU), for E2E Profile 7m. For each transmitted Data, there is an instance of this typedef.

E2E_P07mProtectStateType type

State of the sender for a Data protected with E2E Profile 7m.

E2E_P07ProtectStateType type

State of the sender for a Data protected with E2E Profile 7.

E2E_P08CheckStateType type

State of the reception on one single Data protected with E2E Profile 08

E2E_P08CheckStatusType type

Status of the reception on one single Data in one cycle, protected with E2E Profile 08.

E2E_P08ConfigType type

Configuration of transmitted Data (Data Element or I-PDU), for E2E Profile 08. For each transmitted Data, there is an instance of this typedef.

E2E_P08HeaderInformationType type

Data that can be retrieved from E2E header on receiver side in case E2E Profile 08 is used.

E2E_P08mCheckStateType type

State of the reception on one single Data protected with E2E Profile 08m.

E2E_P08mCheckStatusType type

Status of the reception on one single Data in one cycle, protected with E2E Profile 08m.

E2E_P08mConfigType type

Configuration of transmitted Data (Data Element or I-PDU), for E2E Profile 08m. For each transmitted Data, there is an instance of this typedef.

E2E_P08mProtectStateType type

State of the sender for a Data protected with E2E Profile 08m.

E2E_P08ProtectStateType type

State of the sender for a Data protected with E2E Profile 08.

E2E_P11CheckStateType type

Description: State of the reception on one single Data protected with E2E Profile 11.

E2E_P11CheckStatusType type

Status of the reception on one single Data in one cycle, protected with E2E Profile 11.

E2E_P11ConfigType type

Configuration of transmitted Data (Data Element or I-PDU), for E2E Profile 11. For each transmitted Data, there is an instance of this typedef.

E2E_P11ProtectStateType type

State of the sender for a Data protected with E2E Profile 11.

E2E_P22CheckStateType type

State of the sender for a Data protected with E2E Profile 22.

E2E_P22CheckStatusType type

Result of the verification of the Data in E2E Profile 22, determined by the Check function.

E2E_P22ConfigType type

Non-modifiable configuration of the data element sent over an RTE port, for E2E profile 22. The position of the counter and CRC is not configurable in profile 22.

E2E_P22ConfigType#2 type

Non-modifiable configuration of the data element sent over an RTE port, for E2E profile 22. The position of the counter and CRC is not configurable in profile 22.

E2E_P22ProtectStateType type

State of the sender for a Data protected with E2E Profile 22.

E2E_P44CheckStateType type

State of the reception on one single Data protected with E2E Profile 44.

E2E_P44CheckStatusType type

Status of the reception on one single Data in one cycle, protected with E2E Profile 44.

E2E_P44ConfigType type

Configuration of transmitted Data (Data Element or I-PDU), for E2E Profile 44. For each transmitted Data, there is an instance of this typedef.

E2E_P44HeaderInformationType type

Data that can be retrieved from E2E header on receiver side in case E2E Profile 44 is used.

E2E_P44mCheckStateType type

State of the reception on one single Data protected with E2E Profile 44m.

E2E_P44mCheckStatusType type

Status of the reception on one single Data in one cycle, protected with E2E Profile 44m.

E2E_P44mConfigType type

Configuration of transmitted Data (Data Element or I-PDU), for E2E Profile 44m. For each transmitted Data, there is an instance of this typedef.

E2E_P44mProtectStateType type

State of the sender for a Data protected with E2E Profile 44m.

E2E_P44ProtectStateType type

State of the sender for a Data protected with E2E Profile 44.

E2E_PCheckStatusType type

Profile-independent status of the reception on one single Data in one cycle.

E2E_SMCheckStateType type

State of the protection of a communication channel.

E2E_SMConfigType type

Configuration of a communication channel for exchanging Data.

E2E_SMStateType type

Status of the communication channel exchanging the data. If the status is OK, then the data may be used.

Efx

<InType Mn> function

This service makes a comparison between the two arguments

boolean Efx_Gt_<InType Mn><InType Mn>_<OutType Mn>(<InType> x_value, <InType> y_value);

Efx_Abs_InTypeMn1_OutTypeMn function

This routine computes the absolute value of a signed value

<OutType> Efx_Abs_<InTypeMn1>_<OutTypeMn>(<InType1> x_value);

Efx_Add_InTypeMnInTypeMn_OutTypeMn function

This service makes an addition between the two arguments The addition is protected against the overflow.

<OutType> Efx_Add_<InTypeMn><InTypeMn>_<OutTypeMn>(<InType> x_value, <InType> y_value);

Efx_ArcCos_s16_u16 function

This service computes the inverse cosine of a value.

uint16 Efx_ArcCos_s16_u16(sint16 x_value);

Efx_ArcCos_s32_u32 function

This service computes the inverse cosine of a value.

uint32 Efx_ArcCos_s32_u32(sint32 x_value);

Efx_ArcCos_s8_u8 function

This service computes the inverse cosine of a value.

uint8 Efx_ArcCos_s8_u8(sint8 x_value);

Efx_ArcSin_s32_s32 function

This service computes the inverse sine of a value.

sint32 Efx_ArcSin_s32_s32(sint32 x_value);

Efx_ArcSin_s8_s8 function

This service computes the inverse sine of a value.

sint8 Efx_ArcSin_s8_s8(sint8 x_value);

Efx_Array_Average_InTypeMn_OutTypeMn function

The routine returns average value of an array.

<OutType> Efx_Array_Average_<InTypeMn>_<OutTypeMn>(const <InType>* Array, uint16 Count);

Efx_ArsSin_s16_s16 function

This service computes the inverse sine of a value.

sint16 Efx_ArsSin_s16_s16(sint16 x_value);

Efx_Average_s32_s32 function

The routine returns average value.

sint32 Efx_Average_s32_s32(sint32 value1, sint32 value2);

Efx_CalcTeQ_s32 function

This routine calculates time equivalent factor

sint32 Efx_CalcTeQ_s32(sint32 T1rec_s32, sint32 dT_s32);

Efx_CalcTeQApp_s32 function

This routine calculates time equivalent factor

sint32 Efx_CalcTeQApp_s32(sint32 T1rec_s32, sint32 dT_s32);

Efx_Cast_InTypeMn_OutTypeMn function

Convert value of entry type in the value in the output type

<OutType> Efx_Cast_<InType Mn>_<OutType Mn>(<InType> x_value);

Efx_Cos_s16_s16 function

This service computes the cosine of an angle.

sint16 Efx_Cos_s16_s16(sint16 x_value);

Efx_Cos_s32_s32 function

This service computes the cosine of an angle.

sint32 Efx_Cos_s32_s32(sint32 x_value);

Efx_Cos_s8_s8 function

This service computes the cosine of an angle.

sint8 Efx_Cos_s8_s8(sint8 x_value);

Efx_Counter_InTypeMn_OutTypeMn function

The counter routines increments the value of the parameter CounterVal by 1.

<OutType> Efx_Counter_<InTypeMn>_<OutTypeMn>(<InType>* CounterVal);

Efx_CounterSet_InTypeMn function

The CounterSet routines initialise counter value with initial value • CounterVal = Val;

void Efx_CounterSet_<InTypeMn>(<InType>* CounterVal, <InType> Val);

Efx_CtrlSetLimits function

Update limit structure

void Efx_CtrlSetLimits(Efx_Limits_Type* Limit_cpst, sint32 Min_s32, sint32 Max_s32);

Efx_Debounce_u8_u8 function

This routine debounces a digital input signal and returns the state of the signal as a boolean value.

boolean Efx_Debounce_u8_u8(boolean X, Efx_DebounceState_Type* State, const Efx_DebounceParam_Type* Param, sint32 dT);

Efx_DebounceInit function

This routine call shall stop the debouncing timer.

void Efx_DebounceInit(Efx_DebounceState_Type* State, boolean X);

Efx_DebounceSetParam function

This routine sets timing parameters, time for high to low transition and time for low to high for debouncing.

void Efx_DebounceSetParam(Efx_DebounceParam_Type* Param, sint16 THighLow, sint16 TLowHigh);

Efx_Div_InTypeMnInTypeMn_OutTypeMn function

These services make a division between the two arguments

<OutType> Efx_Div_<InTypeMn><InTypeMn>_<OutTypeMn>(<InType> x_value, <InType> y_value);

Efx_DT1Typ1Calc function

This routine computes DT1 controller output value using differential equation, Yn= exp(-dT/T1) * Yn-1+ K * (1- exp(-dT/T1)) * ((Xn-1 - Xn-2) / dT)

void Efx_DT1Typ1Calc(sint32 X_s32, Efx_StateDT1Typ1_Type* State_cpst, sint32 K_s32, sint32 TeQ_s32, sint32 dT_s32);

Efx_DT1Typ1Out_OutTypeMn function

This routine returns 'DT1' controller's output value.

<OutType> Efx_DT1Typ1Out_<OutTypeMn>(const Efx_StateDT1Typ1_Type* State_cpst);

Efx_DT1Typ1SetState function

The routine initialises internal state variables of a DT1 element.

void Efx_DT1Typ1SetState(Efx_StateDT1Typ1_Type* State_cpst, sint32 X1_s32, sint32 X2_s32, sint16 Y1_s16);

Efx_DT1Typ2Calc function

This routine computes DT1 controller output value using differential equation, Yn= exp(-dT/T1) * Yn-1+ K * (1- exp(-dT/T1)) * ((Xn - Xn-1) / dT)

void Efx_DT1Typ2Calc(sint32 X_s32, Efx_StateDT1Typ2_Type* State_cpst, sint32 K_s32, sint32 TeQ_s32, sint32 dT_s32);

Efx_DT1Typ2Out_OutTypeMn function

This routine returns 'DT1' controller's output value.

<OutType> Efx_DT1Typ2Out_<OutTypeMn>(const Efx_StateDT1Typ2_Type* State_cpst);

Efx_DT1Typ2SetState function

The routine initialises internal state variables of a DT1 element.

void Efx_DT1Typ2SetState(Efx_StateDT1Typ2_Type* State_cpst, sint32 X1_s32, sint16 Y1_s16);

Efx_EdgeBipol_u8_u8 function

This routine detects whether a signal has changed since the last call and returns TRUE. If signal has not changed then returns FALSE.

boolean Efx_EdgeBipol_u8_u8(boolean Inp_Val, boolean* Old_Val);

Efx_EdgeFalling_u8_u8 function

Returns TRUE when the signal has a falling edge, i.e. the signal was TRUE at the last call and FALSE at the actual call of this routine

boolean Efx_EdgeFalling_u8_u8(boolean Inp_Val, boolean* Old_Val);

Efx_EdgeRising_u8_u8 function

Returns TRUE when the signal has a rising edge, i.e. the signal was FALSE at the last call and TRUE at the actual call of this routine

boolean Efx_EdgeRising_u8_u8(boolean Inp_Val, boolean* Old_Val);

Efx_Exp_s32_s32 function

The routine returns exponential value of an input value.

sint32 Efx_Exp_s32_s32(sint32 Value1);

Efx_GetVersionInfo function

Returns the version information of this library.

void Efx_GetVersionInfo(Std_VersionInfoType* versioninfo);

Efx_HpFilter_s16_s32 function

This service computes the output of a first order high-Pass filter

sint32 Efx_HpFilter_s16_s32(sint32 Yn-1, sint16 Xn, sint16 Xn-1, uint16 K);

Efx_HpFilter_s8_s16 function

This service computes the output of a first order high-Pass filter

sint16 Efx_HpFilter_s8_s16(sint16 Yn-1, sint8 Xn, sint8 Xn-1, uint16 K);

Efx_HpFilter_u16_s32 function

This service computes the output of a first order high-Pass filter

sint32 Efx_HpFilter_u16_s32(sint32 Yn-1, uint16 Xn, uint16 Xn-1, uint16 K);

Efx_HpFilter_u8_s16 function

This service computes the output of a first order high-Pass filter

sint16 Efx_HpFilter_u8_s16(sint16 Yn-1, uint8 Xn, uint8 Xn-1, uint16 K);

Efx_Hypot_u16u16_u16 function

This service computes the length of a vector

uint16 Efx_Hypot_u16u16_u16(uint16 x_value, uint16 y_value);

Efx_Hypot_u32u32_u32 function

This service computes the length of a vector

uint32 Efx_Hypot_u32u32_u32(uint32 x_value, uint32 y_value);

Efx_Hypot_u8u8_u8 function

This service computes the length of a vector

uint8 Efx_Hypot_u8u8_u8(uint8 x_value, uint8 y_value);

Efx_HystCenterHalfDelta_InTypeMn_OutTypeMn function

Hysteresis with center and left and right side halfDelta switching point.

boolean Efx_HystCenterHalfDelta_<InTypeMn>_<OutTypeMn>(<InType> X, <InType> center, <InType> halfDelta, boolean* State);

Efx_HystDeltaRight_InTypeMn_OutTypeMn function

Hysteresis with right switching point and delta to left switching point

boolean Efx_HystDeltaRight_<InTypeMn>_<OutTypeMn>(<InType> X, <InType> Delta, <InType> Rsp, boolean* State);

Efx_Hysteresis_InTypeMn_OutTypeMn function

The routine estimates the output of the hysteresis.

<OutType> Efx_Hysteresis_<InTypeMn>_<OutTypeMn>(<InType> input, <InType> thresholdLow, <InType> thresholdHigh, <InType> Out_Val, <InType> Out_LowThresholdVal, <InType> Out_HighThresholdVal);

Efx_HystLeftDelta_InTypeMn_OutTypeMn function

Hysteresis with left switching point and delta to right switching point.

boolean Efx_HystLeftDelta_<InTypeMn>_<OutTypeMn>(<InType> X, <InType> Lsp, <InType> Delta, boolean* State);

Efx_HystLeftRight_InTypeMn_OutTypeMn function

Hysteresis with left and right switching point.

boolean Efx_HystLeftRight_<InTypeMn>_<OutTypeMn>(<InType> X, <InType> Lsp, <InType> Rsp, boolean* State);

Efx_ICalc function

This routine computes 'I' controller output value using differential equation, Yn = Yn-1 + K * dT * Xn-1

void Efx_ICalc(sint32 X_s32, Efx_StateI_Type* State_cpst, sint32 K_s32, sint32 dT_s32);

Efx_ILimCalc function

This routine computes DT1 controller output value using differential equation, Yn = Yn-1 + K * d T * Xn-1

void Efx_ILimCalc(sint32 X_s32, Efx_StateI_Type* State_cpst, sint32 K_s32, const Efx_Limits_Type* Limit_cpst, sint32 dT_s32);

Efx_IntervalClosed_InTypeMn_OutTypeMn function

This routine compares a value 'InpVal' with lower and upper limit 'MinVal' and 'MaxVal' respectively.

boolean Efx_IntervalClosed_<InTypeMn>_<OutTypeMn>(<InType> MinVal, <InType> InpVal, <InType> MaxVal);

Efx_IntervalLeftOpen_InTypeMn_OutTypeMn function

This routine compares a value 'InpVal' with lower and upper limit 'MinVal' and 'MaxVal' respectively.

boolean Efx_IntervalLeftOpen_<InTypeMn>_<OutTypeMn>(sint32 MinVal, sint32 InpVal, sint32 MaxVal);

Efx_IntervalOpen_InTypeMn_OutTypeMn function

This routine compares a value 'InpVal' with lower and upper limit 'MinVal' and 'MaxVal' respectively.

boolean Efx_IntervalOpen_<InTypeMn>_<OutTypeMn>(sint32 MinVal, sint32 InpVal, sint32 MaxVal);

Efx_IntervalRightOpen_InTypeMn_OutTypeMn function

This routine compares a value 'InpVal' with lower and upper limit 'MinVal' and 'MaxVal' respectively.

boolean Efx_IntervalRightOpen_<InTypeMn>_<OutTypeMn>(sint32 MinVal, sint32 InpVal, sint32 MaxVal);

Efx_IOut_OutTypeMn function

This routine returns 'I' controller's output value.

<OutType> Efx_IOut_<OutTypeMn>(const Efx_StateI_Type* State_cpst);

Efx_ISetState function

The routine initialises internal state variables of an I element.

void Efx_ISetState(Efx_StateI_Type* State_cpst, sint32 X1_s32, sint16 Y1_s16);

Efx_LpFilter_InTypeMn_OutTypeMn function

This service computes the first one order discrete filter

<OutType> Efx_LpFilter_<InTypeMn>_<OutTypeMn>(<InType> input, <InType> old_output, uint32 tau_const, uint16 recurrence, uint8 reset, <InType> init_val, uint8* started);

Efx_LpFilterFac1_InTypeMnInTypeMnInTypeMn_OutTypeMn function

This service computes the output of a first order low-pass filter

<OutType> Efx_LpFilterFac1_<InTypeMn><InTypeMn><InTypeMn>_<OutTypeMn>(<InType> Yn-1, <InType> Xn, <InType> fac);

Efx_MedianSort_InTypeMn_OutTypeMn function

Sort an array and return its median value

<OutType> Efx_MedianSort_<InTypeMn>_<OutTypeMn>(<InType>* Array, uint8 N);

Efx_Mod_TypeMn function

This routine returns the remainder of the division x_value / y_value if y_value is not zero.

<Type> Efx_Mod_<TypeMn>(<Type> x_value, <Type> y_value); ⚠️

Efx_MovingAverage_InTypeMn_OutTypeMn function

The routine returns sliding average value of n - 1 last subsequent values of an array plus one new value.

<OutType> Efx_MovingAverage_<InTypeMn>_<OutTypeMn>(Efx_MovingAvrg<InTypeMn>_Type* state, <InType> value);

Efx_Mul_InTypeMnInTypeMn_OutTypeMn function

This service makes a multiplication between the two arguments The multiplication is protected against the overflow.

<OutType> Efx_Mul_<InTypeMn><InTypeMn>_<OutTypeMn>(<InType> x_value, <InType> y_value);

Efx_PCalc function

This routine computes differential equation Differential equation: Y = K * X

void Efx_PCalc(sint32 X_s32, sint32* P_ps32, sint32 K_s32);

Efx_PDCalc function

This routine computes proportional plus derivative controller output value using differential equation: Yn= K(1+Tv/dT) * Xn - K(Tv/dT) * Xn-1

void Efx_PDCalc(sint32 X_s32, Efx_StatePD_Type* State_cpst, const Efx_ParamPD_Type* Param_cpst, sint32 dT_s32);

Efx_PDOut_OutTypeMn function

This routine returns 'PD' controllers output value.

<OutType> Efx_PDOut_<OutTypeMn>(const Efx_StatePD_Type* State_cpcst);

Efx_PDSetParam function

The routine sets the parameter structure of a PD element.

void Efx_PDSetParam(Efx_ParamPD_Type* Param_cpst, sint32 K_s32, sint32 Tv_s32);

Efx_PDSetState function

The routine initialises internal state variables of a PD element.

void Efx_PDSetState(Efx_StatePD_Type* State_cpst, sint32 X1_s32, sint16 Y1_s16);

Efx_PIDOut_OutTypeMn function

This routine returns 'PID' controllers output value.

<OutType> Efx_PIDOut_<OutTypeMn>(const Efx_StatePID_Type* State_cpst);

Efx_PIDSetParam function

The routine sets the parameter structure of a PID element.

void Efx_PIDSetParam(Efx_ParamPID_Type* Param_cpst, sint32 K_s32, sint32 Tv_s32, sint32 Tnrec_s32);

Efx_PIDSetState function

The routine initialises internal state variables of a PID element.

void Efx_PIDSetState(Efx_StatePID_Type* State_cpst, sint32 X1_s32, sint32 X2_s32, sint16 Y1_s16);

Efx_PIDTyp1Calc function

This routine computes Proportional plus integral plus derivative controller (implicit type) output value using differential equation: Yn=Yn-1+ K * (1 + Tv/dT) * Xn- K *(1 - dT/Tn + 2Tv/dT) * Xn-1 + K * (Tv/dT) * Xn-2

void Efx_PIDTyp1Calc(sint32 X_s32, Efx_StatePID_Type* State_cpst, const Efx_ParamPID_Type* Param_cpst, sint32 dT_s32);

Efx_PIDTyp1LimCalc function

void Efx_PIDTyp1LimCalc(sint32 X_s32, Efx_StatePID_Type* State_cpst, const Efx_ParamPID_Type* Param_cpst, const Efx_Limits_Type* Limit_cpst, sint32 dT_s32);

Efx_PIDTyp2Calc function

This routine computes Proportional plus integral plus derivative controller (explicit type) output value using differential equation: Yn = Yn-1 + K * (1 + dT/Tn+ Tv/dT) * Xn- K *(1 + 2Tv/dT) * Xn-1+ K * (Tv/dT) * Xn-2

void Efx_PIDTyp2Calc(sint32 X_s32, Efx_StatePID_Type* State_cpst, const Efx_ParamPID_Type* Param_cpst, sint32 dT_s32);

Efx_PIDTyp2LimCalc function

void Efx_PIDTyp2LimCalc(sint32 X_s32, Efx_StatePID_Type* State_cpst, const Efx_ParamPID_Type* Param_cpst, const Efx_Limits_Type* Limit_cpst, sint32 dT_s32);

Efx_PIOut_OutTypeMn function

This routine returns 'PI' controllers output value.

<OutType> Efx_PIOut_<OutTypeMn>(const Efx_StatePI_Type* State_cpst);

Efx_PISetParam function

The routine sets the parameter structure of a PI element.

void Efx_PISetParam(Efx_ParamPI_Type* Param_cpst, sint32 K_s32, sint32 Tnrec);

Efx_PISetState function

The routine initialises internal state variables of a PI element.

void Efx_PISetState(Efx_StatePI_Type* State_cpst, sint32 X1_s32, sint16 Y1_s16);

Efx_PITyp1Calc function

This routine computes Proportional plus integral controller (implicit type) output value using differential equation: Yn= Yn-1+ K * Xn - K * (1 - dT/Tn) * Xn-1

void Efx_PITyp1Calc(sint32 X_s32, Efx_StatePI_Type* State_cpst, const Efx_ParamPI_Type* Param_cpst, sint32 dT_s32);

Efx_PITyp1LimCalc function

This routine computes Proportional plus integral controller (implicit type) output value using differential equation: Yn = Yn-1+ K * Xn - K * (1 - dT/Tn) * Xn-1

void Efx_PITyp1LimCalc(sint32 X_s32, Efx_StatePI_Type* State_cpst, const Efx_ParamPI_Type* Param_cpst, const Efx_Limits_Type* Limit_cpst, sint32 dT_s32);

Efx_PITyp2Calc function

This routine computes Proportional plus integral controller (explicit type) output value using differential equation: Yn= Yn-1 + K * (1 + dT/Tn) * Xn - K * Xn-1

void Efx_PITyp2Calc(sint32 X_s32, Efx_StatePI_Type* State_cpst, const Efx_ParamPI_Type* Param_cpst, sint32 dT_s32);

Efx_PITyp2LimCalc function

This routine computes Proportional plus integral controller (explicit type) output value using differential equation: Yn = Yn-1 + K * (1 + dT/Tn) * Xn - K * Xn-1

void Efx_PITyp2LimCalc(sint32 X_s32, Efx_StatePI_Type* State_cpst, const Efx_ParamPI_Type* Param_cpst, const Efx_Limits_Type* Limit_cpst, sint32 dT_s32);

Efx_POut_OutTypeMn function

This routine returns 'P' controllers output value.

<OutType> Efx_POut_<OutTypeMn>(const sint32* P_ps32);

Efx_PSetState function

The routine sets the internal state variables of a P element.

void Efx_PSetState(sint32* P_s32, sint16 Y_s16);

Efx_PT1Calc function

This routine computes PT1 controller output value using below difference equation Yn = exp(-d T/T1) * Yn-1+ K(1 - exp(-dT/T1)) * Xn-1

void Efx_PT1Calc(sint32 X_s32, Efx_StatePT1_Type* State_cpst, sint32 K_s32, sint32 TeQ_s32);

Efx_PT1Out_OutTypeMn function

This routine returns 'PT1' controllers output value.

<OutType> Efx_PT1Out_<OutTypeMn>(const Efx_StatePT1_Type* State_cpst);

Efx_PT1SetState function

The routine initialises internal state variables of a PT1 element.

void Efx_PT1SetState(Efx_StatePT1_Type* State_cpst, sint32 X1_s32, sint16 Y1_s16);

Efx_PT1Typ1Calc function

This routine computes PT1 controller output value using below difference equation Yn = exp(-d T/T1) * Yn-1+ K(1 - exp(-dT/T1)) * Xn

void Efx_PT1Typ1Calc(sint32 X_s32, Efx_StatePT1_Type* State_cpst, sint32 K_s32, sint32 TeQ_s32);

Efx_RampCalc function

The ramp output value increases or decreases a value with slope * dT_s32 depending if (State_ cpst->State_s32 < X_s32) or (State_cpst->State_s32 > X_s32).

void Efx_RampCalc(sint32 X_s32, Efx_StateRamp_Type* State_cpst, const Efx_ParamRamp_Type* Param_cpcst, sint32 dT_s32);

Efx_RampCalcJump function

This routine works in addition to main ramp function Efx_RampCalc to provide a faster adaption to target value.

void Efx_RampCalcJump(sint32 X_s32, Efx_StateRamp_Type* State_cpst);

Efx_RampCalcSwitch function

This routine switches between two target values for a ramp service based on a Switch parameter.

sint32 Efx_RampCalcSwitch(sint32 Xa_s32, sint32 Xb_s32, boolean Switch, Efx_StateRamp_Type* State_cpst);

Efx_RampCheckActivity function

This routine checks the status of the ramp and returns TRUE if the ramp is active, otherwise it returns FALSE.

boolean Efx_RampCheckActivity(const Efx_StateRamp_Type* State_cpst);

Efx_RampGetSwitchPos function

Gets the current switch position of ramp switch function.

boolean Efx_RampGetSwitchPos(const Efx_StateRamp_Type* State_cpst);

Efx_RampInitState function

Initializes the state, direction and switch parameters for the ramp.

void Efx_RampInitState(Efx_StateRamp_Type* State_cpst, sint32 Val_s32);

Efx_RampOut_s32 function

Returns the internal state of the ramp element.

sint32 Efx_RampOut_s32(const Efx_StateRamp_Type* State_cpcst);

Efx_RampSetParam function

Sets the slope parameter for the ramp provided by the structure Efx_ParamRamp_Type.

void Efx_RampSetParam(Efx_ParamRamp_Type* Param_cpst, uint32 SlopePosVal_u32, uint32 SlopeNegVal_u32);

Efx_RSFlipFlop function

RS flip flop can be set and reset via input switches R_Val and S_Val.

boolean Efx_RSFlipFlop(boolean R_Val, boolean S_Val, boolean* State_Val);

Efx_Sgn_s64_s8 function

Signum function. Extract the sign of an integer value.

sint8 Efx_Sgn_s64_s8(sint64 x_value);

Efx_Sin_s16_s16 function

This service computes the sine of an angle.

sint16 Efx_Sin_s16_s16(sint16 x_value);

Efx_Sin_s32_s32 function

This service computes the sine of an angle.

sint32 Efx_Sin_s32_s32(sint32 x_value);

Efx_Sin_s8_s8 function

This service computes the sine of an angle.

sint8 Efx_Sin_s8_s8(sint8 x_value);

Efx_SlewRate_InTypeMn function

The routine limits the increase and the decrease of the Input entry by using tunable slopes.

void Efx_SlewRate_<InTypeMn>(<InType> limit_pos, <InType> input, <InType> limit_neg, <InType>* output, uint8* init);

Efx_SortAscend_InTypeMn function

The sorting algorithm modifies the given input array and rearranges data in ascending order.

void Efx_SortAscend_<InTypeMn>(<OutType>* Array, uint16 Num);

Efx_SortDescend_InTypeMn function

The sorting algorithm modifies the given input array and rearranges data in descending order.

void Efx_SortDescend_<InTypeMn>(<OutType>* Array, uint16 Num);

Efx_Sqrt_u16_u16 function

This service computes the square root of a value

uint16 Efx_Sqrt_u16_u16(uint16 x_value);

Efx_Sqrt_u32_u32 function

This service computes the square root of a value

uint32 Efx_Sqrt_u32_u32(uint32 x_value);

Efx_Sqrt_u8_u8 function

This service computes the square root of a value

uint8 Efx_Sqrt_u8_u8(uint8 x_value);

Efx_Sub_InTypeMn1InTypeMn2_OutTypeMn function

This routine makes a subtraction between the two arguments.

<OutType> Efx_Sub_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x_value, <InType2> y_value);

Efx_TypeLimiter_InTypeMn_OutTypeMn function

limiter routine

<OutType> Efx_TypeLimiter_<InTypeMn>_<OutTypeMn>(<InType> Input_Val);

Efx_DebounceParam_Type type

Structure definition for Debounce routine

Efx_DebounceState_Type type

Structure definition for Debounce routine

Efx_Limits_Type type

Controller limit value structure

Efx_MovingAvrgS16_Type type

Structure definition for sliding average routine for sint16 input value

Efx_MovingAvrgS32_Type type

Structure definition for sliding average routine for sint32 input value

Efx_ParamPD_Type type

System and Time equivalent parameter Structure for PD controller routine

Efx_ParamPI_Type type

System and Time equivalent parameter Structure for PI additive ( Type1 and Type 2 ) controller routine

Efx_ParamPID_Type type

System and Time equivalent parameter Structure for PID additive ( Type1 and Type 2 ) controller routine

Efx_ParamRamp_Type type

Structure definition for Ramp routine

Efx_StateDT1Typ1_Type type

System State Structure for DT1-Type1 controller routine

Efx_StateDT1Typ2_Type type

System State Structure for DT1-Type2 controller routine

Efx_StateI_Type type

System State Structure for I controller routine

Efx_StatePD_Type type

System State Structure for PD controller routine

Efx_StatePI_Type type

System State Structure for PI additive ( Type1 and Type 2 ) controller routine

Efx_StatePID_Type type

System State Structure for PID additive ( Type1 and Type 2 ) controller routine

Efx_StatePT1_Type type

System State Structure for PT1 controller routine

Efx_StateRamp_Type type

Structure definition for Ramp routine

Ifl

Ifl_DPSearch_f32 function

This routine searches the position of input Xin within the given distribution array X_array, and returns index and ratio necessary for interpolation.

void Ifl_DPSearch_f32(Ifl_DPResultF32_Type* dpResult, float32 Xin, uint32 N, const float32* X_array);

Ifl_GetVersionInfo function

Returns the version information of this library.

void Ifl_GetVersionInfo(Std_VersionInfoType* versioninfo);

Ifl_Interpolate_f32 function

Returns the result of the linear interpolation (Result), determined according to the following equation.

float32 Ifl_Interpolate_f32(float32 Value1, float32 Value2, float32 Coef);

Ifl_IntIpoCur_f32_f32 function

This routine calculates interpolation of a curve at position Xin using below equa-tion.

float32 Ifl_IntIpoCur_f32_f32(float32 X_in, uint32 N, const float32* X_array, const float32* Val_array);

Ifl_IntIpoMap_f32f32_f32 function

This routine calculates Interpolation of a map at position X and Y using below equations.

float32 Ifl_IntIpoMap_f32f32_f32(float32 Xin, float32 Yin, uint32 Nx, uint32 Ny, const float32* X_array, const float32* Y_array, const float32* Val_array);

Ifl_IpoCub_f32 function

Based on searched indices and ratios information using the relevant Ifl_DPSearch_f32 routine, this routine calculates and returns the interpolation result for a 3D cuboid.

float32 Ifl_IpoCub_f32(const Ifl_DPResultF32_Type* dpResultX, const Ifl_DPResultF32_Type* dpResultY, const Ifl_DPResultF32_Type* dpResultZ, uint16 num_x, uint16 num_y, const float32* Val_array);

Ifl_IpoCub_InTypeMn_f32 function

Based on searched indices and ratios information using the relevant Ifl_DPSearch_f32 routine, this routine calculates and returns the interpolation result for a 3D cuboid.

float32 Ifl_IpoCub_<InTypeMn>_f32(const Ifl_DPResultF32_Type* dpResultX, const Ifl_DPResultF32_Type* dpResultY, const Ifl_DPResultF32_Type* dpResultZ, uint16 num_x, uint16 num_y, const <InType>* Val_array);

Ifl_IpoCur_f32 function

Based on searched index and ratio information, this routine calculates and returns interpolation for curve.

float32 Ifl_IpoCur_f32(const Ifl_DPResultF32_Type* dpResult, const float32* Val_array);

Ifl_IpoCur_InTypeMn_f32 function

Based on searched indices and ratios information using the relevant Ifl_DPSearch_f32 routine, this routine calculates and returns the interpolation result for a curve.

float32 Ifl_IpoCur_<InTypeMn>_f32(const Ifl_DPResultF32_Type* dpResult, const <InType>* Val_array);

Ifl_IpoMap_f32 function

Based on searched indices and ratios information using the Ifl_DPSearch_f32 routine, this routine calculates and returns the interpolation result for map.

float32 Ifl_IpoMap_f32(const Ifl_DPResultF32_Type* dpResultX, const Ifl_DPResultF32_Type* dpResultY, uint32 num_value, const float32* Val_array);

Ifl_IpoMap_InTypeMn_f32 function

Based on searched indices and ratios information using the relevant Ifl_DPSearch_f32 routine, this routine calculates and returns the interpolation result for a map.

float32 Ifl_IpoMap_<InTypeMn>_f32(const Ifl_DPResultF32_Type* dpResultX, const Ifl_DPResultF32_Type* dpResultY, uint32 num_value, const <InType>* Val_array);

Ifl_DPResultF32_Type type

Structure used for data point search for index and ratio

Ifx

Ifx_DPSearch_InTypeMn function

Ifx_DPSearch_<InTypeMn> routine searches the position of input Xin within the given distribution array X_array, and returns index and ratio necessary for interpolation.

void Ifx_DPSearch_<InTypeMn>(Ifx_DPResultU16_Type* dpResult, <InType> Xin, <InType> N, const <InType>* X_array);

Ifx_GetVersionInfo function

Returns the version information of this library.

void Ifx_GetVersionInfo(Std_VersionInfoType* versioninfo);

Ifx_IntIpoCur_InTypeMn_OutTypeMn function

This routine calculates interpolation of a curve at position Xin using below equation.

<OutType> Ifx_IntIpoCur_<InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> N, const <InType>* X_array, const <InType>* Val_array);

Ifx_IntIpoFixCur_InTypeMn_OutTypeMn function

This routine calculates interpolation of a curve at position Xin using below equations.

<OutType> Ifx_IntIpoFixCur_<InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> N, const <InType>* Val_array, <InType> Offset, <InType> Shift);

Ifx_IntIpoFixICur_InTypeMn_OutTypeMn function

This routine calculates interpolation of a curve at position Xin using below equations.

<OutType> Ifx_IntIpoFixICur_<InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> N, const <InType>* Val_array, <InType> Offset, <InType> Interval);

Ifx_IntIpoFixIMap_InTypeMnInTypeMn_OutTypeMn function

This routine calculates Interpolation of a map at position X and Y using below equations.

<OutType> Ifx_IntIpoFixIMap_<InTypeMn><InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> Yin, <InType> Nx, <InType> Ny, const <InType>* Val_array, <InType> OffsetX, <InType> IntervalX, <InType> OffsetY, <InType> IntervalY);

Ifx_IntIpoFixMap_InTypeMnInTypeMn_OutTypeMn function

This routine calculates Interpolation of a map at position X and Y using below equations.

<OutType> Ifx_IntIpoFixMap_<InTypeMn><InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> Yin, <InType> Nx, <inType> Ny, const <InType>* Val_array, <InType> OffsetX, <InType> ShiftX, <InType> OffsetY, <InType> ShiftY);

Ifx_IntIpoMap_InTypeMnInTypeMn_OutTypeMn function

This routine calculates Interpolation of a map at position X and Y using below equations.

<OutType> Ifx_IntIpoMap_<InTypeMn><InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> Yin, <InType> Nx, <InType> Ny, const <InType>* X_array, const <InType>* Y_array, const <InType>* Val_array);

Ifx_IntLkUpBaseMap_InTypeMnInTypeMn_OutTypeMn function

This routine returns respective entry value of the result distribution array at position Xin and Yin based on below equations.

<OutType> Ifx_IntLkUpBaseMap_<InTypeMn><InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> Yin, <InType> Nx, <InType> Ny, const <InType>* X_array, const <InType>* Y_array, const <InType>* Val_array);

Ifx_IntLkUpCur_InTypeMn_OutTypeMn function

This routine returns respective entry value of the result at position Xin based on below equations.

<OutType> Ifx_IntLkUpCur_<InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> N, const <InType>* X_array, const <InType>* Val_array);

Ifx_IntLkUpFixBaseMap_InTypeMnInTypeMn_OutTypeMn function

This routine returns respective entry value of the result distribution array at position Xin and Yin based on below equations.

<OutType> Ifx_IntLkUpFixBaseMap_<InTypeMn><InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> Yin, <InType> Nx, <InType> Ny, const <InType>* Val_array, <InType> OffsetX, <InType> ShiftX, <InType> OffsetY, <InType> ShiftY);

Ifx_IntLkUpFixCur_InTypeMn_OutTypeMn function

This routine returns respective entry value of the result distribution array at position Xin based on below equations.

<OutType> Ifx_IntLkUpFixCur_<InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> N, const <InType>* Val_array, <InType> Offset, <InType> Shift);

Ifx_IntLkUpFixIBaseMap_InTypeMnInTypeMn_OutTypeMn function

This routine returns respective entry value of the result distribution array at position Xin and Yin based on below equations.

<OutType> Ifx_IntLkUpFixIBaseMap_<InTypeMn><InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> Yin, <InType> Nx, <InType> Ny, const <InType>* Val_array, <InType> OffsetX, <InType> IntervalX, <InType> OffsetY, <InType> IntervalY);

Ifx_IntLkUpFixICur_InTypeMn_OutTypeMnt function

This routine returns respective entry value of the result distribution array at position Xin based on below equations.

<OutType> Ifx_IntLkUpFixICur_<InTypeMn>_<OutTypeMnt>(<InType> Xin, <InType> N, const <InType>* Val_array, <InType> Offset, <InType> Interval);

Ifx_IntLkUpFixIMap_InTypeMnInTypeMn_OutTypeMn function

This routine returns respective entry value of the result distribution array at position Xin and Yin based on below equations.

<OutType> Ifx_IntLkUpFixIMap_<InTypeMn><InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> Yin, <InType> Nx, <InType> Ny, const <InType>* Val_array, <InType> OffsetX, <InType> IntervalX, <InType> OffsetY, <InType> IntervalY);

Ifx_IntLkUpFixMap_InTypeMnInTypeMn_OutTypeMn function

This routine returns respective entry value of the result distribution array at position Xin and Yin based on below equations.

<OutType> Ifx_IntLkUpFixMap_<InTypeMn><InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> Yin, <InType> Nx, <InType> Ny, const <InType>* Val_array, <InType> OffsetX, <InType> ShiftX, <InType> OffsetY, <InType> ShiftY);

Ifx_IntLkUpMap_InTypeMnInTypeMn_OutTypeMn function

This routine returns respective entry value of the result distribution array at position Xin and Yin based on below equations.

<OutType> Ifx_IntLkUpMap_<InTypeMn><InTypeMn>_<OutTypeMn>(<InType> Xin, <InType> Yin, <InType> Nx, <InType> Ny, const <InType>* X_array, const <InType>* Y_array, const <InType>* Val_array);

Ifx_IpoCub_OutTypeMn function

Based on searched indices and ratios information using the relevant Ifx_DPSearch routine, this routine calculates and returns the interpolation result for a 3D cuboid.

<OutType> Ifx_IpoCub_<OutTypeMn>(const Ifx_DPResultU16_Type* dpResultX, const Ifx_DPResultU16_Type* dpResultY, const Ifx_DPResultU16_Type* dpResultZ, uint16 num_x, uint16 num_y, const <InType>* Val_array);

Ifx_IpoCur_OutTypeMn function

Based on searched index and ratio information, this routine calculates and returns interpolation for curve.

<OutType> Ifx_IpoCur_<OutTypeMn>(const Ifx_DPResultU16_Type* dpResult, const <InType>* Val_array);

Ifx_IpoMap_OutTypeMn function

Based on searched indices and ratios information using the relevant Ifx_DPSearch routine, this routine calculates and returns the interpolation result for map.

<OutType> Ifx_IpoMap_<OutTypeMn>(const Ifx_DPResultU16_Type* dpResultX, const Ifx_DPResultU16_Type* dpResultY, uint16 num_value, const <InType>* Val_array);

Ifx_LkUpBaseMap_OutTypeMn function

Based on searched index and ratio information, this routine calculates and returns entry value of the result distribution array.

<OutType> Ifx_LkUpBaseMap_<OutTypeMn>(const Ifx_DPResultU16_Type* dpResultX, const Ifx_DPResultU16_Type* dpResultY, uint16 num_value, const <InType>* Val_array);

Ifx_LkUpCur_OutTypeMn function

Based on searched index and ratio information, this routine calculates and returns entry point of the result array.

<OutType> Ifx_LkUpCur_<OutTypeMn>(const Ifx_DPResultU16_Type* dpResult, const <InType>* Val_array);

Ifx_LkUpMap_OutTypeMn function

Based on searched index and ratio information, this routine calculates and returns entry value of the result distribution array.

<OutType> Ifx_LkUpMap_<OutTypeMn>(const Ifx_DPResultU16_Type* dpResultX, const Ifx_DPResultU16_Type* dpResultY, uint16 num_value, const <InType>* Val_array);

Ifx_DPResultU16_Type type

Structure used for data point search for index and ratio

Mfl

Mfl function

Returns the Integer value for the corresponding floating point input.

<OutType> Mfl(float32 ValFloat);

Mfl_Abs_f32 function

Returns the absolute value of the argument (ValAbs), determined according to the following equation.

float32 Mfl_Abs_f32(float32 ValValue);

Mfl_arcCos_f32 function

Returns the arc cosine of an angle, in the range of 0.0 through pi.

float32 Mfl_arcCos_f32(float32 value);

Mfl_ArcCos_f32 function

Returns the arc cosine of an angle, in the range of 0.0 through pi.

float32 Mfl_ArcCos_f32(float32 value);

Mfl_arcSin_f32 function

Returns the arc sine of an angle, in the range of -pi/2 through pi/2.

float32 Mfl_arcSin_f32(float32 value);

Mfl_ArcSin_f32 function

Returns the arc sine of an angle, in the range of -pi/2 through pi/2.

float32 Mfl_ArcSin_f32(float32 value);

Mfl_arcTan2_f32 function

Returns the arc tangent of an angle, in the range of [-pi to pi]

float32 Mfl_arcTan2_f32(float32 X1_f32, float32 X2_f32);

Mfl_ArcTan2_f32 function

Returns the arc tangent of an angle, in the range of [-pi to pi]

float32 Mfl_ArcTan2_f32(float32 y, float32 x);

Mfl_arcTan_f32 function

Returns the arc tangent of an angle, in the range of -pi/2 through pi/2.

float32 Mfl_arcTan_f32(float32 value);

Mfl_ArcTan_f32 function

Returns the arc tangent of an angle, in the range of -pi/2 through pi/2.

float32 Mfl_ArcTan_f32(float32 value);

Mfl_ArrayAverage_f32_f32 function

The routine returns average value of an array.

float32 Mfl_ArrayAverage_f32_f32(const float32* Array, uint32 Count);

Mfl_Average_f32_f32 function

The routine returns average value.

float32 Mfl_Average_f32_f32(float32 value1, float32 value2);

Mfl_Bitpat_f32_u32 function

Return the bit representation of the single point precision float value

uint32 Mfl_Bitpat_f32_u32(float32 Value);

Mfl_CalcTeQ_f32 function

This routine calculates time equivalent factor

float32 Mfl_CalcTeQ_f32(float32 T1rec_f32, float32 dT_f32);

Mfl_CalcTeQApp_f32 function

This routine calculates time equivalent factor

float32 Mfl_CalcTeQApp_f32(float32 T1rec_f32, float32 dT_f32);

Mfl_Ceil_f32 function

Returns the integer value determined by rounding the argument toward positive infinity.

float32 Mfl_Ceil_f32(float32 ValValue);

Mfl_Cos_f32 function

Calculates the cosine of the argument.

float32 Mfl_Cos_f32(float32 value);

Mfl_Cos_s32_f32 function

Fast cosine calculation

float32 Mfl_Cos_s32_f32(sint32 x_value);

Mfl_CtrlSetLimit function

Update limit structure

void Mfl_CtrlSetLimit(float32 Min_f32, float32 Max_f32, Mfl_Limits_Type* Limit_cpst);

Mfl_CtrlSetLimits function

Update limit structure

void Mfl_CtrlSetLimits(Mfl_Limits_Type* Limit_cpst, float32 Min_f32, float32 Max_f32);

Mfl_Cvrt_f32_OutTypeMn function

Returns the integer value of the fixed point result of the conversion, determined according to the following equation.

<OutType> Mfl_Cvrt_f32_<OutTypeMn>(float32 ValFloat, sint16 ValFixedExponent);

Mfl_Cvrt_InTypeMn_f32 function

Returns the floating-point result of the conversion, determined according to the following equation.

float32 Mfl_Cvrt_<InTypeMn>_f32(<InType> ValFixedInteger, sint16 ValFixedExponent);

Mfl_DeadTime_f32_f32 function

This routine returns input value with specified delay time.

float32 Mfl_DeadTime_f32_f32(float32 X, float32 DelayTime, float32 StepTime, Mfl_DeadTimeParam_Type* Param);

Mfl_Debounce_u8_u8 function

This routine debounces a digital input signal and returns the state of the signal as a boolean value.

boolean Mfl_Debounce_u8_u8(boolean X, Mfl_DebounceState_Type* State, const Mfl_DebounceParam_Type* Param, float32 dT);

Mfl_DebounceInit function

This routine call shall stop the debouncing timer.

void Mfl_DebounceInit(Mfl_DebounceState_Type* State, boolean X);

Mfl_DebounceSetparam function

This routine sets timing parameters, time for high to low transition and time for low to high for debouncing.

void Mfl_DebounceSetparam(Mfl_DebounceParam_Type* Param, float32 THighLow, float32 TLowHigh);

Mfl_DebounceSetParam function

This routine sets timing parameters, time for high to low transition and time for low to high for debouncing.

void Mfl_DebounceSetParam(Mfl_DebounceParam_Type* Param, float32 THighLow, float32 TLowHigh);

Mfl_DT1Typ1Calc function

This routine computes DT1 controller output value using differential equation

void Mfl_DT1Typ1Calc(float32 X_f32, Mfl_StateDT1Typ1_Type* State_cpst, float32 K_f32, float32 TeQ_f32, float32 dT_f32);

Mfl_DT1Typ1Out_f32 function

This routine returns 'DT1' controller's output value

float32 Mfl_DT1Typ1Out_f32(const Mfl_StateDT1Typ1_Type* State_cpst);

Mfl_DT1Typ1SetState function

The routine initialises internal state variables of a DT1 element.

void Mfl_DT1Typ1SetState(Mfl_StateDT1Typ1_Type* State_cpst, float32 X1_f32, float32 X2_f32, float32 Y1_f32);

Mfl_DT1Typ2Calc function

This routine computes DT1 controller output value using differential equation

void Mfl_DT1Typ2Calc(float32 X_f32, Mfl_StateDT1Typ2_Type* State_cpst, float32 K_f32, float32 TeQ_f32, float32 dT_f32);

Mfl_DT1Typ2Out_f32 function

This routine returns 'DT1' controller's output value

float32 Mfl_DT1Typ2Out_f32(const Mfl_StateDT1Typ2_Type* State_cpst);

Mfl_DT1Typ2SetState function

The routine initialises internal state variables of a DT1 element.

void Mfl_DT1Typ2SetState(Mfl_StateDT1Typ2_Type* State_cpst, float32 X1_f32, float32 Y1_f32);

Mfl_Exp_f32 function

Returns the exponential of the operand (ValExp), determined according to the following equation.

float32 Mfl_Exp_f32(float32 ValValue);

Mfl_Floor_f32 function

Returns the natural number value determined by rounding the argument toward negative infinity.

float32 Mfl_Floor_f32(float32 ValValue);

Mfl_GetVersionInfo function

Returns the version information of this library.

void Mfl_GetVersionInfo(Std_VersionInfoType* versioninfo);

Mfl_Hypot_f32f32_f32 function

This service computes the length of a vector

float32 Mfl_Hypot_f32f32_f32(float32 x_value, float32 y_value);

Mfl_HystCenterHalfDelta_f32_u8 function

Hysteresis with center and left and right side halfDelta switching point.

boolean Mfl_HystCenterHalfDelta_f32_u8(float32 X, float32 center, float32 halfDelta, uint8* State);

Mfl_HystDeltaRight_f32_u8 function

Hysteresis with right switching point and delta to left switching point

boolean Mfl_HystDeltaRight_f32_u8(float32 X, float32 Delta, float32 Rsp, uint8* State);

Mfl_HystLeftDelta_f32_u8 function

Hysteresis with left switching point and delta to right switching point.

boolean Mfl_HystLeftDelta_f32_u8(float32 X, float32 Lsp, float32 Delta, uint8* State);

Mfl_HystLeftRight_f32_u8 function

Hysteresis with left and right switching point.

boolean Mfl_HystLeftRight_f32_u8(float32 X, float32 Lsp, float32 Rsp, uint8* State);

Mfl_ICalc function

This routine computes I controller output value using differential equation

void Mfl_ICalc(float32 X_f32, Mfl_StateI_Type* State_cpst, float32 K_f32, float32 dT_f32);

Mfl_ILimCalc function

This routine computes I controller output value using differential equation

void Mfl_ILimCalc(float32 X_f32, Mfl_StateI_Type* State_cpst, float32 K_f32, const Mfl_Limits_Type* Limit_cpst, float32 dT_f32);

Mfl_IntToFloatCvrt_InTypeMn_f32 function

Returns the Float value for the corresponding Integer input.

float32 Mfl_IntToFloatCvrt_<InTypeMn>_f32(<InType> ValInteger);

Mfl_IOut_f32 function

This routine returns 'I' controllers output value.

float32 Mfl_IOut_f32(const Mfl_StateI_Type* State_cpst);

Mfl_ISetState function

The routine initialises internal state variables of an I element.

void Mfl_ISetState(Mfl_StateI_Type* State_cpst, float32 X1_f32, float32 Y1_f32);

Mfl_Limit_f32 function

Returns the bounded value (newVal), determined according to the following equation.

float32 Mfl_Limit_f32(float32 val, float32 lowLim, float32 upLim);

Mfl_Log_f32 function

Returns the natural (base-e) logarithm of the operand (ValLog), determined according to the following equation.

float32 Mfl_Log_f32(float32 ValValue);

Mfl_Max_f32 function

Returns the value of the larger of the two arguments (ValMax), determined according to the following equation.

float32 Mfl_Max_f32(float32 ValValue1, float32 ValValue2);

Mfl_MedianSort_f32_f32 function

This routine sorts values of an array in ascending order. Input array passed by the pointer shall have sorted values after this routine call. If N is set incorrectly there is a security risk of buffer overrun. Memory corruption is possible, if parameter N is greater than the array size. Therefore N is recommended to be a constant, not a variable.

float32 Mfl_MedianSort_f32_f32(float32* Array, uint8 N);

Mfl_Min_f32 function

Returns the value of the smaller of the two arguments (Min), determined according to the following equation.

float32 Mfl_Min_f32(float32 Value1, float32 Value2);

Mfl_PCalc function

Differential equation: Y = K * X

void Mfl_PCalc(float32 X_f32, float32* P_pf32, float32 K_f32);

Mfl_PDCalc function

This routine computes proportional plus derivative controller output value using differential equation

void Mfl_PDCalc(float32 X_f32, Mfl_StatePD_Type* State_cpst, const Mfl_ParamPD_Type* Param_cpst, float32 dT_f32);

Mfl_PDOut_f32 function

This routine returns 'PD' controllers output value.

float32 Mfl_PDOut_f32(const Mfl_StatePD_Type* State_cpst);

Mfl_PDSetParam function

The routine sets the parameter structure of a PD element.

void Mfl_PDSetParam(Mfl_ParamPD_Type* Param_cpst, float32 K_f32, float32 Tv_f32);

Mfl_PDSetState function

The routine initialises internal state variables of a PD element.

void Mfl_PDSetState(Mfl_StatePD_Type* State_cpst, float32 X1_f32, float32 Y1_f32);

Mfl_PIDOut_f32 function

This routine returns 'PID' controllers output value.

float32 Mfl_PIDOut_f32(const Mfl_StatePID_Type* State_cpst);

Mfl_PIDSetParam function

The routine sets the parameter structure of a PID element.

void Mfl_PIDSetParam(Mfl_ParamPID_Type* Param_cpst, float32 K_f32, float32 Tv_f32, float32 Tnrec_f32);

Mfl_PIDSetState function

The routine initialises internal state variables of a PID element.

void Mfl_PIDSetState(Mfl_StatePID_Type* State_cpst, float32 X1_f32, float32 X2_f32, float32 Y1_f32);

Mfl_PIDTyp1Calc function

This routine computes Proportional plus integral plus derivative controller (implicit type) output value using differential equation

void Mfl_PIDTyp1Calc(float32 X_f32, Mfl_StatePID_Type* State_cpst, const Mfl_ParamPID_Type* Param_cpst, float32 dT_f32);

Mfl_PIDTyp1LimCalc function

This routine computes Proportional plus integral plus derivative controller (implicit type) output value using differential equation

void Mfl_PIDTyp1LimCalc(float32 X_f32, Mfl_StatePID_Type* State_cpst, const Mfl_ParamPID_Type* Param_cpst, const Mfl_Limits_Type* Limit_cpst, float32 dT_f32);

Mfl_PIDTyp2Calc function

This routine computes Proportional plus integral plus derivative controller (explicit type) output value using differential equation

void Mfl_PIDTyp2Calc(float32 X_f32, Mfl_StatePID_Type* State_cpst, const Mfl_ParamPID_Type* Param_cpst, float32 dT_f32);

Mfl_PIDTyp2LimCalc function

This routine computes Proportional plus integral plus derivative controller (explicit type) output value using differential equation

void Mfl_PIDTyp2LimCalc(float32 X_f32, Mfl_StatePID_Type* State_cpst, const Mfl_ParamPID_Type* Param_cpst, const Mfl_Limits_Type* Limit_cpst, float32 dT_f32);

Mfl_PIOut_f32 function

This routine returns 'PI' controllers output value.

float32 Mfl_PIOut_f32(const Mfl_StatePI_Type* State_cpst);

Mfl_PISetParam function

The routine sets the parameter structure of a PI element.

void Mfl_PISetParam(Mfl_ParamPI_Type* Param_cpst, float32 K_f32, float32 Tnrec_f32);

Mfl_PISetState function

The routine initialises internal state variables of a PI element.

void Mfl_PISetState(Mfl_StatePI_Type* State_cpst, float32 X1_f32, float32 Y1_f32);

Mfl_PITyp1Calc function

This routine computes Proportional plus integral controller (implicit type) output value using differential equation

void Mfl_PITyp1Calc(float32 X_f32, Mfl_StatePI_Type* State_cpst, const Mfl_ParamPI_Type* Param_cpst, float32 dT_f32);

Mfl_PITyp1LimCalc function

This routine computes Proportional plus integral controller (implicit type) output value using differential equation

void Mfl_PITyp1LimCalc(float32 X_f32, Mfl_StatePI_Type* State_cpst, const Mfl_ParamPI_Type* Param_cpst, const Mfl_Limits_Type* Limit_cpst, float32 dT_f32);

Mfl_PITyp2Calc function

This routine computes Proportional plus integral controller (explicit type) output value using differential equation

void Mfl_PITyp2Calc(float32 X_f32, Mfl_StatePI_Type* State_cpst, const Mfl_ParamPI_Type* Param_cpst, float32 dT_f32);

Mfl_PITyp2LimCalc function

This routine computes Proportional plus integral controller (explicit type) output value using differential equation

void Mfl_PITyp2LimCalc(float32 X_f32, Mfl_StatePI_Type* State_cpst, const Mfl_ParamPI_Type* Param_cpst, const Mfl_Limits_Type* Limit_cpst, float32 dT_f32);

Mfl_POut_f32 function

This routine returns 'P' controllers output value limited by the return data type

float32 Mfl_POut_f32(const float32* P_pf32);

Mfl_Pow_f32 function

Returns the ValBase raised to ValExp power, determined according to the following equation.

float32 Mfl_Pow_f32(float32 ValBase, float32 ValExp);

Mfl_PT1Calc function

This routine computes PT1 controller output value using below difference equation

void Mfl_PT1Calc(float32 X_f32, Mfl_StatePT1_Type* State_cpst, float32 K_f32, float32 TeQ_f32);

Mfl_PT1Out_f32 function

This routine returns 'PT1' controllers output value

float32 Mfl_PT1Out_f32(const Mfl_StatePT1_Type* State_cpst);

Mfl_PT1SetState function

The routine initialises internal state variables of a PT1 element.

void Mfl_PT1SetState(Mfl_StatePT1_Type* State_cpst, float32 X1_f32, float32 Y1_f32);

Mfl_PT1Typ1Calc function

This routine computes PT1 controller output value using below difference equation Yn = exp(-d T/T1) * Yn-1+ K(1 - exp(-dT/T1)) * Xn

void Mfl_PT1Typ1Calc(float32 X_f32, Mfl_StatePT1_Type* State_cpst, float32 K_f32, float32 TeQ_f32);

Mfl_RampCalc function

The ramp output value increases or decreases a value with slope * dT_f32 depending if (State_ cpst->State_f32 > X_f32) or (State_cpst->State_f32 < X_f32).

void Mfl_RampCalc(float32 X_f32, Mfl_StateRamp_Type* State_cpst, const Mfl_ParamRamp_Type* Param_cpcst, float32 dT_f32);

Mfl_RampCalcJump function

This routine works in addition to main ramp function Mfl_RampCalc to provide a faster adaption to target value. If ramp is still rising (or falling) and target value is not reached, then input value of ramp jumps to a lower (or higher) value of current ramp state, ramp will jump to that value immediately. This functionality is helpful if input target value of ramp changes its direction often and significantly and ramp should reach target value faster than without that functionality. If the target is reached or the target does not change its direction, the standard behaviour of ramp functionality is untouched. In general, this routine decides whether a jump has to be done or not, if there is a change in the target. After a call to this function, Mfl_RampCalc function shall be called to execute the standard ramp behaviour.

void Mfl_RampCalcJump(float32 X_f32, Mfl_StateRamp_Type* State_cpst);

Mfl_RampCalcSwitch function

This routine switches between two target values for a ramp service based on a Switch parameter.

float32 Mfl_RampCalcSwitch(float32 Xa_f32, float32 Xb_f32, boolean Switch, Mfl_StateRamp_Type* State_cpst);

Mfl_RampCalcSwitch_f32 function

This routine switches ramp between two target values based on the Switch value.

float32 Mfl_RampCalcSwitch_f32(float32 Xa_f32, float32 Xb_f32, Mfl_StateRamp_Type* State_cpst, const Mfl_ParamRamp_Type* Param_cpcst, float32 dT_f32);

Mfl_RampCheckActivity function

This routine checks the status of the ramp and returns a TRUE if the ramp is active, otherwise it returns FALSE.

boolean Mfl_RampCheckActivity(const Mfl_StateRamp_Type* State_cpst);

Mfl_RampGetSwitchPos function

Gets the current switch position of ramp switch function.

boolean Mfl_RampGetSwitchPos(const Mfl_StateRamp_Type* State_cpst);

Mfl_RampInitState function

Initializes the state, direction and switch parameters for the ramp.

void Mfl_RampInitState(Mfl_StateRamp_Type* State_cpst, float32 Val_f32);

Mfl_RampOut_f32 function

Returns the internal state of the ramp element.

float32 Mfl_RampOut_f32(const Mfl_StateRamp_Type* State_cpcst);

Mfl_RampSetParam function

Sets the slope parameter for the ramp provided by the structure Mfl_ParamRamp_Type.

void Mfl_RampSetParam(Mfl_ParamRamp_Type* Param_cpst, float32 SlopePosVal_f32, float32 SlopeNegVal_f32);

Mfl_RateLimiter_f32 function

An increasing value and decreasing value is rate limited by maxdif

float32 Mfl_RateLimiter_f32(float32 newval, float32 oldval, float32 maxdif);

Mfl_Round_f32 function

Returns the integer value determined by rounding the argument toward the nearest whole number.

float32 Mfl_Round_f32(float32 ValValue);

Mfl_RSqrt_f32 function

Fast reciprocal square root of the operand (ValSqrt)

float32 Mfl_RSqrt_f32(float32 ValValue);

Mfl_Sign_f32 function

Returns the sign of the argument (ValSign), determined according to the following equation.

sint8 Mfl_Sign_f32(float32 ValValue);

Mfl_Sin_f32 function

Calculates the sine of the argument.

float32 Mfl_Sin_f32(float32 value);

Mfl_Sin_s32_f32 function

Fast sine calculation

float32 Mfl_Sin_s32_f32(sint32 x_value);

Mfl_SortAscend_f32 function

The sorting algorithm modifies the given input array in ascending order & returns sorted array result via pointer

void Mfl_SortAscend_f32(float32* Array, uint16 Num);

Mfl_SortDescend_f32 function

The sorting algorithm modifies the given input array in descending order & returns sorted array result via pointer

void Mfl_SortDescend_f32(float32* Array, uint16 Num);

Mfl_Sqrt_f32 function

Returns the square root of the operand (ValSqrt), determined according to the following equation

float32 Mfl_Sqrt_f32(float32 ValValue);

Mfl_Tan_f32 function

Calculates the tangent of the argument.

float32 Mfl_Tan_f32(float32 value);

Mfl_Trunc_f32 function

Returns the integer value determined by rounding the argument toward zero.

float32 Mfl_Trunc_f32(float32 ValValue);

Mfl_DeadTimeParam_Type type

Structure definition for Dead Time routine

Mfl_DebounceParam_Type type

Structure definition for Debouncing parameters

Mfl_DebounceState_Type type

Structure definition for Debouncing state variables

Mfl_Limits_Type type

Controller limit value structure

Mfl_ParamPD_Type type

System and Time equivalent parameter Structure for PD controller routine

Mfl_ParamPI_Type type

System and Time equivalent parameter Structure for PI additive ( Type1 and Type 2 ) controller routine

Mfl_ParamPID_Type type

System and Time equivalent parameter Structure for PID additive ( Type1 and Type 2 ) controller routine

Mfl_ParamRamp_Type type

Structure definition for Ramp routine

Mfl_StateDT1Typ1_Type type

System State Structure for DT1-Type1 controller routine

Mfl_StateDT1Typ2_Type type

System State Structure for DT1-Type2 controller routine

Mfl_StateI_Type type

System State Structure for I controller routine

Mfl_StatePD_Type type

System State Structure for PD controller routine

Mfl_StatePI_Type type

System State Structure for PI additive ( Type1 and Type 2 ) controller routine

Mfl_StatePID_Type type

System State Structure for PID additive ( Type1 and Type 2 ) controller routine

Mfl_StatePT1_Type type

System State Structure for PT1 controller routine

Mfl_StateRamp_Type type

Structure definition for Ramp routine

Mfx

Mfx_Abs_InTypeMn1_OutTypeMn function

This routine computes the absolute value of a signed value.

<OutType> Mfx_Abs_<InTypeMn1>_<OutTypeMn>(<InType1> x_value);

Mfx_AbsDiff_InTypeMn1InTypeMn2_OutTypeMn function

This routine computes the absolute value of a difference between 2 values.

<OutType> Mfx_AbsDiff_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x_value, <InType2> y_value);

Mfx_AbsDiffP2_InTypeMn1InTypeMn2_OutTypeMn function

The routine subtracts and takes the absolute value of two 16-bit integers with scaling factors set by input parameters.

<OutType> Mfx_AbsDiffP2_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x, <InType2> y, sint16 a, sint16 b, sint16 c);

Mfx_AbsP2_s16_OutTypeMn function

The routine takes the absolute value of a 16-bit integer with scaling factors set by input parameters.

<OutType> Mfx_AbsP2_s16_<OutTypeMn>(<InType1> x, sint16 a, sint16 c);

Mfx_AbsP2_s32_OutTypeMn function

The routine takes the absolute value of a 32-bit integer with scaling factors set by input parameters.

<OutType> Mfx_AbsP2_s32_<OutTypeMn>(<InType1> x, sint16 a, sint16 c);

Mfx_Add_InTypeMn1InTypeMn2_OutTypeMn function

This routine makes an addition between the two arguments.

<OutType> Mfx_Add_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x_value, <InType2> y_value);

Mfx_AddP2_InTypeMn1InTypeMn2_OutTypeMn function

The routine adds two 16-bit integers with scaling factors set by input parameters.

<OutType> Mfx_AddP2_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x, <InType2> y, sint16 a, sint16 b, sint16 c);

Mfx_AddP2_InTypeMn1InTypeMn2_OutTypeMn#2 function

The routine adds two 32-bit integers with scaling factors set by input parameters.

<OutType> Mfx_AddP2_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x, <InType2> y, sint16 a, sint16 b, sint16 c);

Mfx_ConvertP2_InTypeMn_OutTypeMn function

The routine converts a scaled 16-bit integer to a scaled 8-bit integer.

<OutType> Mfx_ConvertP2_<InTypeMn>_<OutTypeMn>(<InType> x, sint16 a, sint16 c);

Mfx_ConvertP2_InTypeMn_OutTypeMn#2 function

The routine converts a scaled 8-bit integer to a scaled 16-bit integer.

<OutType> Mfx_ConvertP2_<InTypeMn>_<OutTypeMn>(<InType> x, sint16 a, sint16 c);

Mfx_ConvertP2_InTypeMn_OutTypeMn#3 function

The routine converts a scaled 32-bit integer to a scaled 16-bit integer.

<OutType> Mfx_ConvertP2_<InTypeMn>_<OutTypeMn>(<InType> x, sint16 a, sint16 c);

Mfx_ConvertP2_InTypeMn_OutTypeMn#4 function

The routine converts a scaled 16-bit integer to a scaled 32-bit integer.

<OutType> Mfx_ConvertP2_<InTypeMn>_<OutTypeMn>(<InType> x, sint16 a, sint16 c);

Mfx_Div_InTypeMn1InTypeMn2_OutTypeMn function

These routines make a division between the two arguments.

<OutType> Mfx_Div_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x_value, <InType2> y_value);

Mfx_DivP2_InTypeMn1InTypeMn2_OutTypeMn function

The routine divides two 16-bit integers with scaling factors set by input parameters.

<OutType> Mfx_DivP2_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x, <InType2> y, sint16 a, sint16 b, sint16 c);

Mfx_DivP2_InTypeMn1InTypeMn2_OutTypeMn#2 function

The routine divides two 32-bit integers with scaling factors set by input parameters.

<OutType> Mfx_DivP2_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x, <InType2> y, sint16 a, sint16 b, sint16 c);

Mfx_DivShLeft_InTypeMn1InTypeMn2u8_OutTypeMn function

This routine applies a shift left defined by the third argument to the first argument, and then makes a division by the second argument.

<OutType> Mfx_DivShLeft_<InTypeMn1><InTypeMn2>u8_<OutTypeMn>(<InType1> x_value, <InType2> y_value, uint8 shift);

Mfx_GetVersionInfo function

Returns the version information of this library.

void Mfx_GetVersionInfo(Std_VersionInfoType* versioninfo);

Mfx_Limit_TypeMn function

This routine limits the input value between Lower Bound and Upper Bound.

<Type> Mfx_Limit_<TypeMn>(<Type> value, <Type> min_value, <Type> max_value); ⚠️

Mfx_Max_TypeMn function

This routine returns the maximum between two values.

<Type> Mfx_Max_<TypeMn>(<Type> x_value, <Type> y_value); ⚠️

Mfx_Min_TypeMn function

This routine returns the minimum between two values.

<Type> Mfx_Min_<TypeMn>(<Type> x_value, <Type> y_value); ⚠️

Mfx_Minmax_TypeMn function

The routine limits a value to a minimum or a maximum that depends on the sign of the minmax_ value.

<Type> Mfx_Minmax_<TypeMn>(<Type> value, <Type> minmax_value); ⚠️

Mfx_Mod_TypeMn function

This routine returns the remainder of the division x_value / y_value if y_value is not zero.

<Type> Mfx_Mod_<TypeMn>(<Type> x_value, <Type> y_value); ⚠️

Mfx_Mul_InTypeMn1InTypeMn2_OutTypeMn function

This routine makes a multiplication between the two arguments.

<OutType> Mfx_Mul_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x_value, <InType2> y_value);

Mfx_MulDiv_InTypeMn1InTypeMn2InTypeMn3_OutTypeMn function

These routines make a multiplication between the two arguments and a division by the third argument.

<OutType> Mfx_MulDiv_<InTypeMn1><InTypeMn2><InTypeMn3>_<OutTypeMn>(<InType1> x_value, <InType2> y_value, <InType3> z_value);

Mfx_MulP2_InTypeMn1InTypeMn2_OutTypeMn function

The routine multiplies two 16-bit integers with scaling factors set by input parameters.

<OutType> Mfx_MulP2_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x, <InType2> y, sint16 a, sint16 b, sint16 c);

Mfx_MulP2_InTypeMn1InTypeMn2_OutTypeMn#2 function

The routine multiplies two 32-bit integers with scaling factors set by input parameters.

<OutType> Mfx_MulP2_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x, <InType2> y, sint16 a, sint16 b, sint16 c);

Mfx_MulShRight_InTypeMn1InTypeMn2_OutTypeMn function

This routine makes a multiplication between the two arguments and applies a shift right defined by the third argument.

<OutType> Mfx_MulShRight_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x_value, <InType2> y_value, uint8 shift);

Mfx_RDiv_InTypeMn1InTypeMn2_OutTypeMn function

These routines make a division between the two arguments.

<OutType> Mfx_RDiv_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x_value, <InType2> y_value);

Mfx_RMulDiv_InTypeMn1InTypeMn2InTypeMn3_OutTypeMn function

These routines make a multiplication between the two arguments and a division by the third argument.

<OutType> Mfx_RMulDiv_<InTypeMn1><InTypeMn2><InTypeMn3>_<OutTypeMn>(<InType1> x_value, <InType2> y_value, <InType3> z_value);

Mfx_Sgn_s32_s8 function

Signum function. Extract the sign of an integer value.

sint8 Mfx_Sgn_s32_s8(sint32 x_value);

Mfx_Sub_InTypeMn1InTypeMn2_OutTypeMn function

This routine makes a subtraction between the two arguments.

<OutType> Mfx_Sub_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x_value, <InType2> y_value);

Mfx_SubP2_InTypeMn1InTypeMn2_OutTypeMn function

The routine subtracts two 16-bit integers with scaling factors set by input parameters.

<OutType> Mfx_SubP2_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x, <InType2> y, sint16 a, sint16 b, sint16 c);

Mfx_SubP2_InTypeMn1InTypeMn2_OutTypeMn#2 function

The routine subtracts two 32-bit integers with scaling factors set by input parameters.

<OutType> Mfx_SubP2_<InTypeMn1><InTypeMn2>_<OutTypeMn>(<InType1> x, <InType2> y, sint16 a, sint16 b, sint16 c);

Klicke auf einen Eintrag, um seine Bezüge zu sehen.

AUTOSAR Classic AUTOSAR-Bibliotheken

Themenkarte

Bfx

Bmc

Crc

E2E

Efx

Ifl

Ifx

Mfl

Mfx

Detailansicht

Bfx

Bmc

Crc

E2E

Efx

Ifl

Ifx

Mfl

Mfx

Module im Cluster

BFx Library (Bfx)

BSW Multicore Library (Bmc)

CRC Library (Crc)

E2E Library (E2E)

EFx Library (Efx)

IFl Library (Ifl)

IFx Library (Ifx)

MFl Library (Mfl)

MFx Library (Mfx)

MSF Library (Msf)