AUTOSAR Classic AUTOSAR-Bibliotheken

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

Mapa de temas

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

Vista de detalle

Selecciona una entrada en el índice.

No hay datos de elementos para esta versión

Bfx

Bfx_ClrBit_TypeMnu8 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

Returns the version information of this library.

void Bfx_GetVersionInfo(Std_VersionInfoType* Versioninfo);

Bfx_PutBit_TypeMnu8u8 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

Arithmetic shift with saturation

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

Bfx_ToggleBitMask_TypeMnTypeMn función

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 función

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

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

Bfx_TstBitLnMask_InTypeMnInTypeMn_u8 función

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 función

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 función

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 función

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 función

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

Bmc_CompareExchange_u función

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

Bmc_Exchange_s función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

Atomically sets the value pointed to by Object to false.

void Bmc_FlagClear(volatile Bmc_AtomicFlagType* Object);

Bmc_FlagTestAndSet función

Atomically sets the value pointed to by Object to true.

boolean Bmc_FlagTestAndSet(volatile Bmc_AtomicFlagType* Object);

Bmc_GetVersionInfo función

Returns the version information of this library.

void Bmc_GetVersionInfo(Std_VersionInfoType* Versioninfo);

Bmc_Load_s función

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

Bmc_AtomicSType Bmc_Load_s(const volatile Bmc_AtomicSType* Object);

Bmc_Load_TypeMn función

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

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

Bmc_Load_u función

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

Bmc_AtomicUType Bmc_Load_u(const volatile Bmc_AtomicUType* Object);

Bmc_Store_s función

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 función

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 función

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 función

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 tipo

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

Bmc_AtomicSType tipo

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

Bmc_AtomicUType tipo

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

Crc

Crc_CalculateCRC16 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

This service returns the version information of this module.

void Crc_GetVersionInfo(Std_VersionInfoType* Versioninfo);

E2E

E2E_GetVersionInfo función

Returns the version information of this module.

void E2E_GetVersionInfo(Std_VersionInfoType* VersionInfo);

E2E_P01Check función

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 función

Initializes the check state

Std_ReturnType E2E_P01CheckInit(E2E_P01CheckStateType* StatePtr);

E2E_P01Forward función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P01ProtectInit(E2E_P01ProtectStateType* StatePtr);

E2E_P02Check función

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 función

Initializes the check state

Std_ReturnType E2E_P02CheckInit(E2E_P02CheckStateType* StatePtr);

E2E_P02Forward función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P02ProtectInit(E2E_P02ProtectStateType* StatePtr);

E2E_P04Check función

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 función

Initializes the check state

Std_ReturnType E2E_P04CheckInit(E2E_P04CheckStateType* StatePtr);

E2E_P04Forward función

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 función

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 función

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 función

Initializes the check state

Std_ReturnType E2E_P04mCheckInit(E2E_P04mCheckStateType* StatePtr);

E2E_P04mForward función

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 función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P04mProtectInit(E2E_P04mProtectStateType* StatePtr);

E2E_P04mSinkCheck función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P04ProtectInit(E2E_P04ProtectStateType* StatePtr);

E2E_P05Check función

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 función

Initializes the check state

Std_ReturnType E2E_P05CheckInit(E2E_P05CheckStateType* StatePtr);

E2E_P05Forward función

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 función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P05ProtectInit(E2E_P05ProtectStateType* StatePtr);

E2E_P06Check función

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 función

Initializes the check state

Std_ReturnType E2E_P06CheckInit(E2E_P06CheckStateType* StatePtr);

E2E_P06Forward función

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 función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P06ProtectInit(E2E_P06ProtectStateType* StatePtr);

E2E_P07Check función

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 función

Initializes the check state

Std_ReturnType E2E_P07CheckInit(E2E_P07CheckStateType* StatePtr);

E2E_P07Forward función

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 función

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 función

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 función

Initializes the check state

Std_ReturnType E2E_P07mCheckInit(E2E_P07mCheckStateType* StatePtr);

E2E_P07mForward función

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 función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P07mProtectInit(E2E_P07mProtectStateType* StatePtr);

E2E_P07mSinkCheck función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P07ProtectInit(E2E_P07ProtectStateType* StatePtr);

E2E_P08Check función

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 función

Initializes the check state

Std_ReturnType E2E_P08CheckInit(E2E_P08CheckStateType* StatePtr);

E2E_P08Forward función

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 función

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 función

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 función

Initializes the check state

Std_ReturnType E2E_P08mCheckInit(E2E_P08mCheckStateType* StatePtr);

E2E_P08mForward función

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 función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P08mProtectInit(E2E_P08mProtectStateType* StatePtr);

E2E_P08mSinkCheck función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P08ProtectInit(E2E_P08ProtectStateType* StatePtr);

E2E_P11Check función

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 función

Initializes the check state

Std_ReturnType E2E_P11CheckInit(E2E_P11CheckStateType* StatePtr);

E2E_P11Forward función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P11ProtectInit(E2E_P11ProtectStateType* StatePtr);

E2E_P22Check función

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 función

Initializes the check state

Std_ReturnType E2E_P22CheckInit(E2E_P22CheckStateType* StatePtr);

E2E_P22Forward función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P22ProtectInit(E2E_P22ProtectStateType* StatePtr);

E2E_P44Check función

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 función

Initializes the check state.

Std_ReturnType E2E_P44CheckInit(E2E_P44CheckStateType* StatePtr);

E2E_P44Forward función

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 función

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 función

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 función

Initializes the check state

Std_ReturnType E2E_P44mCheckInit(E2E_P44mCheckStateType* StatePtr);

E2E_P44mForward función

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 función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P44mProtectInit(E2E_P44mProtectStateType* StatePtr);

E2E_P44mSinkCheck función

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 función

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 función

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 función

Initializes the protection state.

Std_ReturnType E2E_P44ProtectInit(E2E_P44ProtectStateType* StatePtr);

E2E_P76Check función

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 función

Initializes the check state Tags: atp.Status=draft

Std_ReturnType E2E_P76CheckInit(E2E_P76CheckStateType* StatePtr);

E2E_P76MapStatusToSM función

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 función

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

Std_ReturnType E2E_P76ProtectInit(E2E_P76ProtectStateType* StatePtr);

E2E_SMCheck función

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 función

Initializes the state machine.

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

E2EPW_ReadInit1_p_o función

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 función

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 función

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 función

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

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

E2E_P01CheckStateType tipo

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

E2E_P01CheckStatusType tipo

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

E2E_P01ConfigType tipo

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 tipo

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 tipo

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

E2E_P02CheckStateType tipo

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

E2E_P02CheckStatusType tipo

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

E2E_P02ConfigType tipo

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 tipo

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

E2E_P04CheckStateType tipo

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

E2E_P04CheckStatusType tipo

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

E2E_P04ConfigType tipo

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 tipo

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

E2E_P04mCheckStateType tipo

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

E2E_P04mCheckStatusType tipo

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

E2E_P04mConfigType tipo

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 tipo

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

E2E_P04ProtectStateType tipo

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

E2E_P05CheckStateType tipo

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

E2E_P05CheckStatusType tipo

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

E2E_P05ConfigType tipo

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 tipo

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

E2E_P05ProtectStateType tipo

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

E2E_P06CheckStateType tipo

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

E2E_P06CheckStatusType tipo

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

E2E_P06ConfigType tipo

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 tipo

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

E2E_P06ProtectStateType tipo

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

E2E_P07CheckStateType tipo

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

E2E_P07CheckStatusType tipo

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

E2E_P07ConfigType tipo

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 tipo

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

E2E_P07mCheckStatusType tipo

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

E2E_P07mConfigType tipo

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 tipo

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

E2E_P07ProtectStateType tipo

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

E2E_P08CheckStateType tipo

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

E2E_P08CheckStatusType tipo

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

E2E_P08ConfigType tipo

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 tipo

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

E2E_P08mCheckStateType tipo

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

E2E_P08mCheckStatusType tipo

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

E2E_P08mConfigType tipo

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 tipo

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

E2E_P08ProtectStateType tipo

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

E2E_P11CheckStateType tipo

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

E2E_P11CheckStatusType tipo

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

E2E_P11ConfigType tipo

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 tipo

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

E2E_P22CheckStateType tipo

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

E2E_P22CheckStatusType tipo

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

E2E_P22ConfigType tipo

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 tipo

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 tipo

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

E2E_P44CheckStateType tipo

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

E2E_P44CheckStatusType tipo

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

E2E_P44ConfigType tipo

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 tipo

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

E2E_P44mCheckStateType tipo

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

E2E_P44mCheckStatusType tipo

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

E2E_P44mConfigType tipo

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 tipo

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

E2E_P44ProtectStateType tipo

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

E2E_PCheckStatusType tipo

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

E2E_SMCheckStateType tipo

State of the protection of a communication channel.

E2E_SMConfigType tipo

Configuration of a communication channel for exchanging Data.

E2E_SMStateType tipo

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

Efx

<InType Mn> función

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 función

This routine computes the absolute value of a signed value

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

Efx_Add_InTypeMnInTypeMn_OutTypeMn función

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 función

This service computes the inverse cosine of a value.

uint16 Efx_ArcCos_s16_u16(sint16 x_value);

Efx_ArcCos_s32_u32 función

This service computes the inverse cosine of a value.

uint32 Efx_ArcCos_s32_u32(sint32 x_value);

Efx_ArcCos_s8_u8 función

This service computes the inverse cosine of a value.

uint8 Efx_ArcCos_s8_u8(sint8 x_value);

Efx_ArcSin_s32_s32 función

This service computes the inverse sine of a value.

sint32 Efx_ArcSin_s32_s32(sint32 x_value);

Efx_ArcSin_s8_s8 función

This service computes the inverse sine of a value.

sint8 Efx_ArcSin_s8_s8(sint8 x_value);

Efx_Array_Average_InTypeMn_OutTypeMn función

The routine returns average value of an array.

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

Efx_ArsSin_s16_s16 función

This service computes the inverse sine of a value.

sint16 Efx_ArsSin_s16_s16(sint16 x_value);

Efx_Average_s32_s32 función

The routine returns average value.

sint32 Efx_Average_s32_s32(sint32 value1, sint32 value2);

Efx_CalcTeQ_s32 función

This routine calculates time equivalent factor

sint32 Efx_CalcTeQ_s32(sint32 T1rec_s32, sint32 dT_s32);

Efx_CalcTeQApp_s32 función

This routine calculates time equivalent factor

sint32 Efx_CalcTeQApp_s32(sint32 T1rec_s32, sint32 dT_s32);

Efx_Cast_InTypeMn_OutTypeMn función

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 función

This service computes the cosine of an angle.

sint16 Efx_Cos_s16_s16(sint16 x_value);

Efx_Cos_s32_s32 función

This service computes the cosine of an angle.

sint32 Efx_Cos_s32_s32(sint32 x_value);

Efx_Cos_s8_s8 función

This service computes the cosine of an angle.

sint8 Efx_Cos_s8_s8(sint8 x_value);

Efx_Counter_InTypeMn_OutTypeMn función

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

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

Efx_CounterSet_InTypeMn función

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

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

Efx_CtrlSetLimits función

Update limit structure

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

Efx_Debounce_u8_u8 función

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 función

This routine call shall stop the debouncing timer.

void Efx_DebounceInit(Efx_DebounceState_Type* State, boolean X);

Efx_DebounceSetParam función

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 función

These services make a division between the two arguments

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

Efx_DT1Typ1Calc función

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 función

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

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

Efx_DT1Typ1SetState función

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 función

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 función

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

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

Efx_DT1Typ2SetState función

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 función

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 función

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 función

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 función

The routine returns exponential value of an input value.

sint32 Efx_Exp_s32_s32(sint32 Value1);

Efx_GetVersionInfo función

Returns the version information of this library.

void Efx_GetVersionInfo(Std_VersionInfoType* versioninfo);

Efx_HpFilter_s16_s32 función

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 función

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 función

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 función

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 función

This service computes the length of a vector

uint16 Efx_Hypot_u16u16_u16(uint16 x_value, uint16 y_value);

Efx_Hypot_u32u32_u32 función

This service computes the length of a vector

uint32 Efx_Hypot_u32u32_u32(uint32 x_value, uint32 y_value);

Efx_Hypot_u8u8_u8 función

This service computes the length of a vector

uint8 Efx_Hypot_u8u8_u8(uint8 x_value, uint8 y_value);

Efx_HystCenterHalfDelta_InTypeMn_OutTypeMn función

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 función

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 función

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 función

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 función

Hysteresis with left and right switching point.

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

Efx_ICalc función

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 función

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 función

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 función

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 función

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 función

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 función

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

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

Efx_ISetState función

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 función

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 función

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 función

Sort an array and return its median value

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

Efx_Mod_TypeMn función

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 función

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 función

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 función

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

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

Efx_PDCalc función

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 función

This routine returns 'PD' controllers output value.

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

Efx_PDSetParam función

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 función

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 función

This routine returns 'PID' controllers output value.

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

Efx_PIDSetParam función

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 función

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 función

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 función

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 función

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 función

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 función

This routine returns 'PI' controllers output value.

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

Efx_PISetParam función

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 función

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 función

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 función

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 función

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 función

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 función

This routine returns 'P' controllers output value.

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

Efx_PSetState función

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

void Efx_PSetState(sint32* P_s32, sint16 Y_s16);

Efx_PT1Calc función

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 función

This routine returns 'PT1' controllers output value.

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

Efx_PT1SetState función

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 función

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 función

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 función

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 función

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 función

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 función

Gets the current switch position of ramp switch function.

boolean Efx_RampGetSwitchPos(const Efx_StateRamp_Type* State_cpst);

Efx_RampInitState función

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

void Efx_RampInitState(Efx_StateRamp_Type* State_cpst, sint32 Val_s32);

Efx_RampOut_s32 función

Returns the internal state of the ramp element.

sint32 Efx_RampOut_s32(const Efx_StateRamp_Type* State_cpcst);

Efx_RampSetParam función

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 función

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 función

Signum function. Extract the sign of an integer value.

sint8 Efx_Sgn_s64_s8(sint64 x_value);

Efx_Sin_s16_s16 función

This service computes the sine of an angle.

sint16 Efx_Sin_s16_s16(sint16 x_value);

Efx_Sin_s32_s32 función

This service computes the sine of an angle.

sint32 Efx_Sin_s32_s32(sint32 x_value);

Efx_Sin_s8_s8 función

This service computes the sine of an angle.

sint8 Efx_Sin_s8_s8(sint8 x_value);

Efx_SlewRate_InTypeMn función

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 función

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 función

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 función

This service computes the square root of a value

uint16 Efx_Sqrt_u16_u16(uint16 x_value);

Efx_Sqrt_u32_u32 función

This service computes the square root of a value

uint32 Efx_Sqrt_u32_u32(uint32 x_value);

Efx_Sqrt_u8_u8 función

This service computes the square root of a value

uint8 Efx_Sqrt_u8_u8(uint8 x_value);

Efx_Sub_InTypeMn1InTypeMn2_OutTypeMn función

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 función

limiter routine

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

Efx_DebounceParam_Type tipo

Structure definition for Debounce routine

Efx_DebounceState_Type tipo

Structure definition for Debounce routine

Efx_Limits_Type tipo

Controller limit value structure

Efx_MovingAvrgS16_Type tipo

Structure definition for sliding average routine for sint16 input value

Efx_MovingAvrgS32_Type tipo

Structure definition for sliding average routine for sint32 input value

Efx_ParamPD_Type tipo

System and Time equivalent parameter Structure for PD controller routine

Efx_ParamPI_Type tipo

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

Efx_ParamPID_Type tipo

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

Efx_ParamRamp_Type tipo

Structure definition for Ramp routine

Efx_StateDT1Typ1_Type tipo

System State Structure for DT1-Type1 controller routine

Efx_StateDT1Typ2_Type tipo

System State Structure for DT1-Type2 controller routine

Efx_StateI_Type tipo

System State Structure for I controller routine

Efx_StatePD_Type tipo

System State Structure for PD controller routine

Efx_StatePI_Type tipo

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

Efx_StatePID_Type tipo

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

Efx_StatePT1_Type tipo

System State Structure for PT1 controller routine

Efx_StateRamp_Type tipo

Structure definition for Ramp routine

Ifl

Ifl_DPSearch_f32 función

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 función

Returns the version information of this library.

void Ifl_GetVersionInfo(Std_VersionInfoType* versioninfo);

Ifl_Interpolate_f32 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 tipo

Structure used for data point search for index and ratio

Ifx

Ifx_DPSearch_InTypeMn función

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 función

Returns the version information of this library.

void Ifx_GetVersionInfo(Std_VersionInfoType* versioninfo);

Ifx_IntIpoCur_InTypeMn_OutTypeMn función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 tipo

Structure used for data point search for index and ratio

Mfl

Mfl función

Returns the Integer value for the corresponding floating point input.

<OutType> Mfl(float32 ValFloat);

Mfl_Abs_f32 función

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

float32 Mfl_Abs_f32(float32 ValValue);

Mfl_arcCos_f32 función

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

float32 Mfl_arcCos_f32(float32 value);

Mfl_ArcCos_f32 función

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

float32 Mfl_ArcCos_f32(float32 value);

Mfl_arcSin_f32 función

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 función

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 función

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 función

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 función

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 función

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 función

The routine returns average value of an array.

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

Mfl_Average_f32_f32 función

The routine returns average value.

float32 Mfl_Average_f32_f32(float32 value1, float32 value2);

Mfl_Bitpat_f32_u32 función

Return the bit representation of the single point precision float value

uint32 Mfl_Bitpat_f32_u32(float32 Value);

Mfl_CalcTeQ_f32 función

This routine calculates time equivalent factor

float32 Mfl_CalcTeQ_f32(float32 T1rec_f32, float32 dT_f32);

Mfl_CalcTeQApp_f32 función

This routine calculates time equivalent factor

float32 Mfl_CalcTeQApp_f32(float32 T1rec_f32, float32 dT_f32);

Mfl_Ceil_f32 función

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

float32 Mfl_Ceil_f32(float32 ValValue);

Mfl_Cos_f32 función

Calculates the cosine of the argument.

float32 Mfl_Cos_f32(float32 value);

Mfl_Cos_s32_f32 función

Fast cosine calculation

float32 Mfl_Cos_s32_f32(sint32 x_value);

Mfl_CtrlSetLimit función

Update limit structure

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

Mfl_CtrlSetLimits función

Update limit structure

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

Mfl_Cvrt_f32_OutTypeMn función

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 función

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 función

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 función

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 función

This routine call shall stop the debouncing timer.

void Mfl_DebounceInit(Mfl_DebounceState_Type* State, boolean X);

Mfl_DebounceSetparam función

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 función

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 función

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 función

This routine returns 'DT1' controller's output value

float32 Mfl_DT1Typ1Out_f32(const Mfl_StateDT1Typ1_Type* State_cpst);

Mfl_DT1Typ1SetState función

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 función

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 función

This routine returns 'DT1' controller's output value

float32 Mfl_DT1Typ2Out_f32(const Mfl_StateDT1Typ2_Type* State_cpst);

Mfl_DT1Typ2SetState función

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 función

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

float32 Mfl_Exp_f32(float32 ValValue);

Mfl_Floor_f32 función

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

float32 Mfl_Floor_f32(float32 ValValue);

Mfl_GetVersionInfo función

Returns the version information of this library.

void Mfl_GetVersionInfo(Std_VersionInfoType* versioninfo);

Mfl_Hypot_f32f32_f32 función

This service computes the length of a vector

float32 Mfl_Hypot_f32f32_f32(float32 x_value, float32 y_value);

Mfl_HystCenterHalfDelta_f32_u8 función

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 función

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 función

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 función

Hysteresis with left and right switching point.

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

Mfl_ICalc función

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 función

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 función

Returns the Float value for the corresponding Integer input.

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

Mfl_IOut_f32 función

This routine returns 'I' controllers output value.

float32 Mfl_IOut_f32(const Mfl_StateI_Type* State_cpst);

Mfl_ISetState función

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 función

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

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

Mfl_Log_f32 función

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 función

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 función

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 función

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 función

Differential equation: Y = K * X

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

Mfl_PDCalc función

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 función

This routine returns 'PD' controllers output value.

float32 Mfl_PDOut_f32(const Mfl_StatePD_Type* State_cpst);

Mfl_PDSetParam función

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 función

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 función

This routine returns 'PID' controllers output value.

float32 Mfl_PIDOut_f32(const Mfl_StatePID_Type* State_cpst);

Mfl_PIDSetParam función

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 función

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 función

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 función

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 función

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 función

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 función

This routine returns 'PI' controllers output value.

float32 Mfl_PIOut_f32(const Mfl_StatePI_Type* State_cpst);

Mfl_PISetParam función

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 función

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 función

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 función

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 función

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 función

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 función

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

float32 Mfl_POut_f32(const float32* P_pf32);

Mfl_Pow_f32 función

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

float32 Mfl_Pow_f32(float32 ValBase, float32 ValExp);

Mfl_PT1Calc función

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 función

This routine returns 'PT1' controllers output value

float32 Mfl_PT1Out_f32(const Mfl_StatePT1_Type* State_cpst);

Mfl_PT1SetState función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

Gets the current switch position of ramp switch function.

boolean Mfl_RampGetSwitchPos(const Mfl_StateRamp_Type* State_cpst);

Mfl_RampInitState función

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

void Mfl_RampInitState(Mfl_StateRamp_Type* State_cpst, float32 Val_f32);

Mfl_RampOut_f32 función

Returns the internal state of the ramp element.

float32 Mfl_RampOut_f32(const Mfl_StateRamp_Type* State_cpcst);

Mfl_RampSetParam función

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 función

An increasing value and decreasing value is rate limited by maxdif

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

Mfl_Round_f32 función

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

float32 Mfl_Round_f32(float32 ValValue);

Mfl_RSqrt_f32 función

Fast reciprocal square root of the operand (ValSqrt)

float32 Mfl_RSqrt_f32(float32 ValValue);

Mfl_Sign_f32 función

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

sint8 Mfl_Sign_f32(float32 ValValue);

Mfl_Sin_f32 función

Calculates the sine of the argument.

float32 Mfl_Sin_f32(float32 value);

Mfl_Sin_s32_f32 función

Fast sine calculation

float32 Mfl_Sin_s32_f32(sint32 x_value);

Mfl_SortAscend_f32 función

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 función

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 función

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

float32 Mfl_Sqrt_f32(float32 ValValue);

Mfl_Tan_f32 función

Calculates the tangent of the argument.

float32 Mfl_Tan_f32(float32 value);

Mfl_Trunc_f32 función

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

float32 Mfl_Trunc_f32(float32 ValValue);

Mfl_DeadTimeParam_Type tipo

Structure definition for Dead Time routine

Mfl_DebounceParam_Type tipo

Structure definition for Debouncing parameters

Mfl_DebounceState_Type tipo

Structure definition for Debouncing state variables

Mfl_Limits_Type tipo

Controller limit value structure

Mfl_ParamPD_Type tipo

System and Time equivalent parameter Structure for PD controller routine

Mfl_ParamPI_Type tipo

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

Mfl_ParamPID_Type tipo

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

Mfl_ParamRamp_Type tipo

Structure definition for Ramp routine

Mfl_StateDT1Typ1_Type tipo

System State Structure for DT1-Type1 controller routine

Mfl_StateDT1Typ2_Type tipo

System State Structure for DT1-Type2 controller routine

Mfl_StateI_Type tipo

System State Structure for I controller routine

Mfl_StatePD_Type tipo

System State Structure for PD controller routine

Mfl_StatePI_Type tipo

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

Mfl_StatePID_Type tipo

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

Mfl_StatePT1_Type tipo

System State Structure for PT1 controller routine

Mfl_StateRamp_Type tipo

Structure definition for Ramp routine

Mfx

Mfx_Abs_InTypeMn1_OutTypeMn función

This routine computes the absolute value of a signed value.

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

Mfx_AbsDiff_InTypeMn1InTypeMn2_OutTypeMn función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

Returns the version information of this library.

void Mfx_GetVersionInfo(Std_VersionInfoType* versioninfo);

Mfx_Limit_TypeMn función

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 función

This routine returns the maximum between two values.

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

Mfx_Min_TypeMn función

This routine returns the minimum between two values.

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

Mfx_Minmax_TypeMn función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

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 función

Signum function. Extract the sign of an integer value.

sint8 Mfx_Sgn_s32_s8(sint32 x_value);

Mfx_Sub_InTypeMn1InTypeMn2_OutTypeMn función

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 función

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 función

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);

Haz clic en una entrada para ver sus relaciones.

AUTOSAR Classic AUTOSAR-Bibliotheken

Mapa de temas

Bfx

Bmc

Crc

E2E

Efx

Ifl

Ifx

Mfl

Mfx

Vista de detalle

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)