EFx Library (Efx)

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

This service computes the first one order discrete filter

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

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

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

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

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

This routine returns 'P' controllers output value.

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

The routine initialises internal state variables of a PT1 element.

This routine calculates time equivalent factor

This routine returns 'PT1' controllers output value.

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)

The routine initialises internal state variables of a DT1 element.

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

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

The routine initialises internal state variables of a PD element.

The routine sets the parameter structure of a PD element.

This routine returns 'PD' controllers output value.

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

The routine initialises internal state variables of an I element.

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

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

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

The routine initialises internal state variables of a PI element.

The routine sets the parameter structure of a PI element.

This routine returns 'PI' controllers output value.

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

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

The routine initialises internal state variables of a PID element.

The routine sets the parameter structure of a PID element.

This routine returns 'PID' controllers output value.

This service computes the square root of a value

This service computes the square root of a value

This service computes the square root of a value

The routine returns exponential value of an input value.

The routine returns average value.

The routine returns average value of an array.

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

This service computes the length of a vector

This service computes the length of a vector

This service computes the length of a vector

This service computes the sine of an angle.

This service computes the sine of an angle.

This service computes the sine of an angle.

This service computes the cosine of an angle.

This service computes the cosine of an angle.

This service computes the cosine of an angle.

This service computes the inverse sine of a value.

This service computes the inverse sine of a value.

This service computes the inverse sine of a value.

This service computes the inverse cosine of a value.

This service computes the inverse cosine of a value.

This service computes the inverse cosine of a value.

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

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

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

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

Returns the internal state of the ramp element.

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

Gets the current switch position of ramp switch function.

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

The routine estimates the output of the hysteresis.

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

Hysteresis with left and right switching point.

Hysteresis with right switching point and delta to left switching point

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

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

This routine call shall stop the debouncing timer.

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

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

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

Sort an array and return its median value

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

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

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

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

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

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

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

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

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

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

limiter routine

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

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

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

These services make a division between the two arguments

This service makes a comparison between the two arguments

This routine calculates time equivalent factor

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

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

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

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

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

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)

The routine initialises internal state variables of a DT1 element.

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

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

Update limit structure

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

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

Returns the version information of this library.

This routine computes the absolute value of a signed value

This routine makes a subtraction between the two arguments.

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

Signum function. Extract the sign of an integer value.

System State Structure for PT1 controller routine

Structure definition for sliding average routine for sint16 input value

Structure definition for Ramp routine

Structure definition for Debounce routine

System State Structure for DT1-Type1 controller routine

System State Structure for DT1-Type2 controller routine

System State Structure for PD controller routine

System and Time equivalent parameter Structure for PD controller routine

System State Structure for I controller routine

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

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

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

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

Controller limit value structure

Structure definition for Ramp routine

Structure definition for Debounce routine

Structure definition for sliding average routine for sint32 input value

Yn = Yn-1 + (((Xn - Yn-1) * fac) >> n) Where 'n' is a shift that depends on the types used by the functions for the factor

In order to converge all the time, the result is corrected for value saturation using the following logic: If (Yn == Yn-1) If (((Xn - Yn-1) * fac) > 0) Yn ++ Else If (((Xn - Yn-1) * fac) < 0) Yn – End If Endif

Here is the list of implemented functions.

If (tau_const==0), then output = input

If (*started==0), then output = init_val This flag is used to indicate the filter state. *Started = 0, indicates that current function call is the first call of the function to trigger initialisation.

This service computes the first one order discrete filter:

if ((reset == 1) or (*started == 0)), then output = init_val

if (*started == 0), then *started=1

Here is the list of implemented functions.

input, old_output, and init_val must have the same resolution and the same physical unit.

tau_const and recurrence must have the same resolution and the same physical unit

: Yn = Yn-1 - (K * Yn-1 / 216) + (Xn - Xn-1)*27 The result is rounded towards zero.

Return value shall be saturated to boundary values in the event of negative or positive overflow.

A saturation correction for converging output to zero is applied to the result : If ((Yn equals Yn-1) and (Yn-1 > 0)) decrement Yn by one If ((Yn equals Yn-1) and (Yn-1 < 0)) increment Yn by one

Yn = Yn-1 - (K* Yn-1 /216) + (Xn - Xn-1)*27 The result is rounded towards zero.

Return value shall be saturated to boundary values in the event of negative or positive overflow.

A saturation correction for converging output to zero is applied to the result : If ((Yn equals Yn-1) and (Yn-1 > 0)) decrement Yn by one If ((Yn equals Yn-1) and (Yn-1 < 0)) increment Yn by one

Yn = Yn-1 - (K* Yn-1 /216) + (Xn - Xn-1)*215 The result is rounded towards zero.

Return value shall be saturated to boundary values in the event of negative or positive overflow.

A saturation correction for converging output to zero is applied to the result : If ((Yn equals Yn-1) and (Yn-1 > 0)) decrement Yn by one If ((Yn equals Yn-1) and (Yn-1 < 0)) increment Yn by one

Yn = Yn-1- (K* Yn-1/216) + (Xn- Xn-1)*215 The result is rounded towards zero.

Return value shall be saturated to boundary values in the event of negative or positive overflow.

A saturation correction for converging output to zero is applied to the result : If ((Yn equals Yn-1) and (Yn-1> 0)) decrement Ynby one If ((Yn equals Yn-1) and (Yn-1< 0)) increment Yn by one

Output value *P_s32 = Y_s16 << 16

The internal state of the P element is stored as (Y_s16 << 16)

Output value = *P_ps32 >> 16

Return value shall be saturated to boundary values of the return data type in case of negative or positive overflow.

Here is the list of implemented functions.

This equation derives implementation : Output_value = (TeQ_s32 * State_cpst->Y1) + K_s32 * (1 - TeQ_s32) * State_cpst->X1 where TeQ_s32 = exp (-dT/T1)

Efx_CalcTeQ_s32 shall be used for calculation of time equivalent parameter TeQ_s32 only if T1 > 0.

If (Teq = 0) then PT1 controller follows Input value, State_cpst->Y1 = k_s32 * State_cpst->X1

calculated Output_value and current input value shall be stored to State_cpst->Y1 and State_cpst->X1 respectively. State_cpst->Y1 = Output_value State_cpst->X1 = X_s32

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_s16 << 16

The internal state of the PT1 element is stored as (Y1_s16 << 16)

Initialisation of input state variable X1. State_cpst->X1 = X1_s32

TeQ = exp(-T1rec_s32 * dT_s32)

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

Output value = State_cpst->Y1_s32 >> 16

Output value shall be normalized by 16 bit right shift of internal state variable.

Return value shall be limited by boundary values of the return data type.

Here is the list of implemented functions.

This equation derives implementation : Output_value = (TeQ * State_cpst->Y1) + K_s32 * (1 - TeQ) * ((State_cpst->X1 - State_ cpst->X2) / dT) where TeQ = exp(-dT/T1) The result shall be Rounded towards Zero.

Efx_CalcTeQ_s32 shall be used for calculation of time equivalent parameter TeQ_s32 only if T1 > 0.

If (Teq = 0), then DT1 controller follows Input value, Output_value = k_s32 * (State_cpst->X1 - State_cpst->X2) / dT.

Calculated Output_value shall be stored to State_cpst->Y1. State_cpst->Y1 = Output_value

Old input value State->cpst->X1 shall be stored to State_cpst- >X2. State_cpst->X2 = State_cpst->X1 Current input value X_s32 shall be stored to State_cpst->X1. State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_s16 << 16

The internal state of the DT1 element is stored as (Y1_s16 << 16)

Initialisation of input state variables X1 and X2. State_cpst->X1 = X1_s32 State_cpst->X2 = X2_s32

Output value = State_cpst->Y1 >> 16

Output value shall be normalized by 16 bit right shift of internal state variable.

Return value shall be limited by boundary values of the return data type.

Here is the list of implemented functions.

This equation derives implementation : Output_value = (Param_cpst->K_C * (1+ Param_cpst->Tv_C/dT_s32) * X_s32) - (Param_cpst->K_C * (Param_cpst->Tv_C/dT_s32) * State_cpst->X1) The result shall be Rounded towards Zero.

Calculated Output_value shall be stored to State_cpst->Y1. State_cpst->Y1 = Output_value

Current input value X_s32 shall be stored to State_cpst->X1. State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_s16 << 16

The internal state of the PD element is stored as (Y1_s16 << 16)

Initialisation of input state variable X1. State_cpst->X1 = X1_s32

Initialisation of amplification factor. Param_cpst->K_C = K_s32

Initialisation of lead time state variable Param_cpst->Tv_C = Tv_s32

Output value = State_cpst->Y1 >> 16

Output value shall be normalized by 16 bit right shift of internal state variable.

Return value shall be limited by boundary values of the return data type.

Here is the list of implemented functions.

This equation derives implementation : Output_value = State_cpst->Y1 + K_s32 * dT_s32 * State_cpst->X1

Calculated Output_value and current input value shall be stored to State_cpst->Y1 and State_cpst->X1 respectively. State_cpst->Y1 = Output_value State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_s16 << 16

The internal state of the DT1 element is stored as (Y1_s16 << 16)

Initialisation of input state variable X1. State_cpst->X1 = X1_s32

Output value = State_cpst->Y1 >> 16

Output value shall be normalized by 16 bit right shift of internal state variable.

Return value shall be limited by boundary values of the return data type.

Here is the list of implemented functions.

This equation derives implementation : Output_value = State_cpst->Y1 + (Param_cpst->K_C * X_s32) - (Param_cpst->K_C * (1 - Param_cpst->Tnrec_C * dT_s32) * State_cpst->X1)

Calculated Output_value shall be stored to State_cpst->Y1. State_cpst->Y1 = Output_value

Current input value X_s32 shall be stored to State_cpst->X1. State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

This equation derives implementation : Output_value = State_cpst->Y1 + (Param_cpst->K_C * (1 + Param_cpst->Tnrec_C * d T_s32) * X_s32) - (Param_cpst->K_C * State_cpst->X1)

Calculated Output_value shall be stored to State_cpst->Y1. State_cpst->Y1 = Output_value

Current input value X_s32 shall be stored to State_cpst->X1. State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_s16 << 16

The internal state of the PD element is stored as (Y1_s16 << 16)

Initialisation of input state variable X1. State_cpst->X1 = X1_s32

Initialisation of amplification factor. Param_cpst->K_C = K_s32

Initialisation of reciprocal follow up time state variable Param_cpst->Tnrec_C = Tnrec_s32

Output value = State_cpst->Y1 >> 16

Output value shall be normalized by 16 bit right shift of internal state variable.

Return value shall be limited by boundary values of the return data type.

Here is the list of implemented functions.

This equation derives implementation : calc1 = Param_cpst->K_C * (1 + t_val) * X_s32 calc2 = Param_cpst->K_C * (1 - dT_s32 * Param_cpst->Tnrec_C + 2 * t_val) * State_ cpst->X1 calc3 = Param_cpst->K_C * t_val * State_cpst->X2 Output_value = State_cpst->Y1 + calc1 - calc2 + calc3 Where t_val = Param_cpst->Tv_C / dT_s32 The result shall be Rounded towards Zero.

Calculated Output_value shall be stored to State_cpst->Y1. State_cpst->Y1 = Output_value

Old input value State_cpst->X1 shall be stored to State_cpst->X2 State_cpst->X2 = State_cpst->X1 Current input value X_s32 shall be stored to State_cpst->X1. State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

This equation derives implementation : calc1 = Param_cpst->K_C * (1 + dT_s32 * Param_cpst->Tnrec_C + t_val) * X_s32 calc2 = Param_cpst->K_C * (1 + 2 * t_val) * State_cpst->X1 calc3 = Param_cpst->K_C * t_val * State_cpst->X2 Output_value = State_cpst->Y1 + calc1 - calc2 + calc3 Where t_val = Param_cpst->Tv_C / dT_s32 The result shall be Rounded towards Zero.

Calculated Output_value shall be stored to State_cpst->Y1. State_cpst->Y1 = Output_value

Old input value State_cpst->X1 shall be stored to State_cpst->X2 State_cpst->X2 = State_cpst->X1 Current input value X_s32 shall be stored to State_cpst->X1. State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_s16 << 16

The internal state of the PD element is stored as (Y1_s16 << 16)

Initialisation of input state variable X1. State_cpst->X1 = X1_s32 Initialisation of input state variable X2. State_cpst->X2 = X2_s32

Initialisation of amplification factor. Param_cpst->K_C = K_s32

Initialisation of lead time state variable Param_cpst->Tv_C = Tv_s32

Initialisation of reciprocal follow up time state variable Param_cpst->Tnrec_C = Tnrec_s32

Output value = State_cpst->Y1 >> 16

Output value shall be normalized by 16 bit right shift of internal state variable.

Return value shall be limited by boundary values of the return data type.

Here is the list of implemented functions.

Result = square_root ( x_value )

The result is rounded off.

Result = square_root ( x_value )

The result is rounded off.

Result = square_root ( x_value )

The result is rounded off.

Output = e-x where x = Value1

Output is quantized by 2ˆ16 Output Range = ([0.00004539....22026.4657948] * 2ˆ16) = [2....1443526462] Input Range = ([-10....10] * 2ˆ16) = [0xFFF60000....0x000A0000]

Output = (Value1 + Value2 ) / 2

The result is rounded towards zero.

Output = (Array[0] + Array[1] + ... + Array[N-1] ) / Count

The result is rounded towards zero.

Here is the list of implemented functions.

state ->p_beg pointer holds start address of an array state ->p_end pointer holds end address of an array state ->p_act pointer holds address of an oldest entry of an array

state ->sum shall store total sum including 'value' & excluding old- est entry state ->sum = state ->sum - *(state ->p_act) + value

In every routine call state ->p_act shall be incremented with wrap around. This increment ensures that oldest entry gets replaced with new entry.

Output_value = state->sum / state->n

If state ->n = 0 the result shall be zero by definition.

The result is rounded towards zero.

Here is the list of implemented functions.

Result = sqrt(x_value * x_value/2 + y_value * y_value/2)

The result is rounded off.

Result = sqrt(x_value * x_value/2 + y_value * y_value/2)

The result is rounded off.

Result = sqrt(x_value * x_value/2 + y_value * y_value/2)

The result is rounded off.

The result is rounded off.

The result is rounded off.

The result is rounded off.

The result is rounded off.

The result is rounded off.

The result is rounded off.

The result is rounded off.

The result is rounded off.

The result is rounded off.

The result is rounded off.

The result is rounded off.

The result is rounded off.

If *init==0, *output=input

Input, limit_pos, limit_neg and output must have the same resolu- tion and the same physical unit.

If the result of the Efx_SlewRate is only computed when some conditions are fulfilled, do not call the slew rate under the condition, but systematically! The slew rate must be called at each recurrence, even if it is not used, because oth- erwise, the output will be frozen to the previous value all the time, if conditions are not fulfilled.

The parameters given for output and init, for which we receive the addresses, must be declared by the caller as private variables and will be initialized at 0, because the function uses the previous values of these outputs (so the stack must not be used).

Physical values of limit_pos and limit_neg are positive. Internally limit_pos is added to output value and limit_neg is substracted from output value to get upper and lower limit band within which output value is limited.

At first step, when *init==0, output takes the value of input and *init will be put at 1.

limit_pos is added to the output and it becomes the maximum value of the new output limit_neg is deducted from the output and it becomes the minimum value of the new output. If input is outside this range, output is limited to these values, in the other case, output takes the value of input

Values of limit_pos and limit_neg shall be adapted to the fre- quency of the call of the service.

Here is the list of implemented functions.

This routine decided if jump has to be done or not in case of change in target. Efx_RampCalc function shall be called after this function that a jump or the standard ramp behaviour is executed.

If ramp direction is rising then ramp increases a value with slope * dT_s32 if (State_cpst->Dir_s8 == RISING) State_cpst->State_s32 = State_cpst->State_s32 + (Param_cpcst->SlopePos_u32 * d T_s32) The minimum value of Param_cpcst->SlopePos_u32 * dT_s32 shall be 1, when Param- >SlopePos > 0. The intermediate results shall be rounded off. Ex: minimum increment of Param_cpcst->SlopePos_u32 * dT_s32 = 1/(2ˆ16*10ˆ6)

If ramp direction is falling then ramp decreases a value with slope * dT_s32 if (State_cpst->Dir_s8 == FALLING) State_cpst->State_s32 = State_cpst->State_s32 - (Param_cpcst->SlopeNeg_u32 * d T_s32) The minimum value of Param_cpcst->SlopeNeg_u32 * dT_s32 shall be 1, when Param->SlopeNeg > 0. The intermediate results shall be rounded off. Ex: minimum decrement of Param_cpcst->SlopeNeg_u32 * dT_s32 = 1/(2ˆ16*10ˆ6)

Direction of the ramp is stored so that a change of the target can be recognized and the output will follow immediately to the new target value. State_cpst->Dir_s8 states are: RISING, FALLING, END.

Comparison of State and Target decides ramp direction If(State_cpst->State_s32 > X_s32) then State_cpst->Dir_s8 = FALLING If(State_cpst->State_s32 < X_s32) then State_cpst->Dir_s8 = RISING If(State_cpst->State_s32 == X_s32) then State_cpst->Dir_s8 = END

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

Ramp direction is initialised with END value. User has no possi- bility to change or modify ramp direction. State_cpst->Dir_s8 = END E.g. of ramp direction states: RISING = 1, FALLING = -1, END = 0

Sets positive and negative ramp slopes. Param_cpst->SlopePos_u32 = SlopePosVal_u32 Param_cpst ->SlopeNeg_u32 = SlopeNegVal_u32

Return Value = State_cpcst->State_s32

If target value changes to a value contrary to current ramp direc- tion and ramp has not reached its old target value then ramp state jumps to new target value immediately. State_cpst->State_s32 = X_s32 State_cpst->Dir_s8 = END

If target value is changed to new value and ramp has reached its old target value then normal ramp behavior is maintained. State_cpst->Dir_s8 = END

Direction of the ramp is stored so that a change of the target can be recognized and the output will follow immediately to the new target value. State_cpst->Dir_s8 states are: RISING, FALLING, END.

Comparison of State and Target decides ramp direction If(State_cpst->State_s32 > X_s32) then State_cpst->Dir_s8 = FALLING If(State_cpst->State_s32 < X_s32) then State_cpst->Dir_s8 = RISING If(State_cpst->State_s32 == X_s32) then State_cpst->Dir_s8 = END

Return value = TRUE if Switch position State_cpst->Switch_s8 = TARGET_A Return value = FALSE if Switch position State_cpst->Switch_s8 = TARGET_B

return value = TRUE, if Ramp is active (State_cpst->Dir_s8 != END) return value = FALSE, if Ramp is inactive (State_cpst->Dir_s8 == END)

If Input < thresholdLow, Then return_value = Out_LowThreshold Val

If Input > thresholdHigh, Then return_value = Out_HighThreshold Val

If thresholdLow  Input  thresholdHigh, then return_value = Out_Val

Input, thresholdLow and thresholdHigh must have the same reso- lution and the same physical unit.

Return_value , Out_Val, Out_LowThresholdVal and Out_High ThresholdVal must have the same resolution and the same physical unit.

Here is the list of implemented functions.

Return value = TRUE, if X > center + halfDelta Return value = FALSE, if X < center - halfDelta Return value is former state value if (center - halfDelta)  X  (center + halfDelta )

Parameters X, center and halfDelta should have the same data type.

State variable shall store the old boolean result.

Here is the list of implemented functions.

Return value = TRUE, if X > Rsp (right switching point) Return value = FALSE, if X < Lsp (left switching point) Return value is former state value if Lsp  X  Rsp

Parameters X, Lsp and Rsp should have the same data type.

State variable shall store the old boolean result.

Rsp shall be always greater than Lsp

Here is the list of implemented functions.

Return value = TRUE if X > Rsp (right switching point) Return value = FALSE if X < (Rsp - Delta) Return value is former state value if (Rsp - Delta)  X  Rsp

Parameters X, Rsp and Delta should have the same data type.

State variable shall store the old boolean result.

Here is the list of implemented functions.

Return value is TRUE if X > (Lsp + Delta) Return value is FALSE if X < Lsp Return value is former state value if Lsp  X  (Lsp + Delta)

Parameters X, Lsp and Delta should have the same data type.

State variable shall store the old boolean result.

Here is the list of implemented functions.

If(X != State->XOld) then check start debouncing.

If transition occurs from FALSE to TRUE (i.e State->XOld = FALSE and X = TRUE), then use Param->TimeLowHigh as debouncing time; otherwise use Param->TimeHighLow.

State->Timer is incremented with sample time for debouncing in- put signal. Once reached to the set period, old state is updated with X. State->Timer += dT; If (State->Timer  (TimePeriod * 10000)) State->XOld = X, and stop the timer, State->Timer = 0 where TimePeriod = Param->TimeLowHigh or Param->TimeHighLow

Old value shall be returned as a output value. Current input is stored to old state. Return value = State->XOld State->XOld = X

Resolution of dT is 10-6 seconds per increment of 1 data repre- sentation unit

State->Timer = 0

Sets the input state to the given init value. State->XOld = X;

Param-> TimeHighLow = THighLow Param-> TimeLowHigh = TLowHigh

Here is the list of implemented functions.

Here is the list of implemented functions.

This routine sorts values of an array in ascending order. Input array passed by the pointer shall have sorted values after this routine call.

Returns the median value of sorted array in case of N is even. Result = (Sorted_array[N/2] + Sorted_array[(N/2) - 1] ) / 2

Here is the list of implemented functions.

if (Inp_Val != *Old_Val) return value = TRUE else return value = FALSE.

Return value = TRUE, If (*Old_Val == TRUE && Inp_Val == FALSE) Return value = FALSE, otherwise.

Return value = TRUE, If (*Old_Val == FALSE && Inp_Val == TRUE) Return value = FALSE, otherwise.

Return value = TRUE, if (MinVal  InpVal  MaxVal) Return value = FALSE, otherwise.

Here is the list of implemented functions.

Return value = TRUE, if (MinVal < InpVal < MaxVal) Return value = FALSE, otherwise.

Here is the list of implemented functions.

Return value = TRUE, if (MinVal < InpVal  MaxVal) Return value = FALSE, otherwise.

Here is the list of implemented functions.

Return value = TRUE, if (MinVal  InpVal < MaxVal) Return value = FALSE, otherwise.

Here is the list of implemented functions.

The return value is the new value of the parameter CounterVal. * CounterVal ++; Return value = *CounterVal;

In case of saturation, counter value shall not be reset to 0 and shall not be incremented. Return value = Saturated value of the counter data type

Here is the list of implemented functions.

Here is the list of implemented functions.

The reset switch is higher prior than the set switch, e.g. R_Val = TRUE, S_Val = TRUE Then state and return value = FALSE

Reset condition : R_Val = TRUE, S_Val = FALSE Then state and return value = FALSE

Set condition : R_Val = FALSE, S_Val = TRUE Then state and return value = TRUE

Invalid condition : R_Val = FALSE, S_Val = FALSE Then state and return value are unchanged

Input value shall be saturated according to the data type of the return parameter. e.g. If return type is sint16 and input data range is uint32, then output value will be limited to sint16 data range.

Here is the list of implemented functions.

Return value = x_value + y_value

Here is the list of implemented functions.

Return value = x_value * y_value

Here is the list of implemented functions.

Return value = x_value / y_value

The result after division by zero is defined by: If x_value  0 then the function returns the maximum value of the output type If x_value < 0 then the function returns the minimum value of the output type

The result is rounded towards 0.

Here is the list of implemented functions.

Extract the sign of an integer value. It is defined as follows: Return-value = {-1, if x_value < 0; 0, if x_value == 0; 1, if x_value > 0}

Return Value = TRUE, if (x_value > y_value), else FALSE.

Returns the median value of sorted array in case of N is odd. Return_Value = Sorted_array [N/2] = 15

In above calculation, N/2 shall be rounded towards zero.

Initialisation of state variable State_cpst->State_s32 = Val_s32

Initialisation of switch variable. User has no possibility to change or modify switch initialization value. State_cpst->Switch_s8 = OFF E.g. of switch states: TARGET_A = 1, TARGET_B = -1, OFF = 0

TeQApp = 1 - (T1rec_s32 * dT_s32) TeQApp is factorised by 2ˆ16 This approximation is valid only when the product of the physical values of T1rec_s32 and dt_s32 is less than 1. i.e, (T1rec_s32 * dT_s32) < 1

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

This equation derives implementation : Output_value = State_cpst->Y1 + K_s32 * dT_s32 * State_cpst->X1

Limit output value with minimum and maximum controller limits. If (Output value < Limit_cpst->Min_C) Then, Output_value = Limit_cpst->Min_C If (Output value > Limit_cpst->Max_C) Then, Output_value = Limit_cpst->Max_C

Calculated Output_value and current input value shall be stored to State_cpst->Y1 and State_cpst->X1 respectively. State_cpst->Y1 = Output_value State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

This equation derives implementation : Output_value = State_cpst->Y1 + (Param_cpst->K_C * X_s32) - (Param_cpst->K_C * (1 - Param_cpst->Tnrec_C * dT_s32) * State_cpst->X1)

Limit output value with minimum and maximum controller limits. If (Output value < Limit_cpst->Min_C) Then, Output_value = Limit_cpst->Min_C If (Output value > Limit_cpst->Max_C) Then, Output_value = Limit_cpst->Max_C

Calculated Output_value shall be stored to State_cpst->Y1. State_cpst->Y1 = Output_value

Current input value X_s32 shall be stored to State_cpst->X1. State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

This equation derives implementation : Output_value = State_cpst->Y1 + (Param_cpst->K_C * (1 + Param_cpst->Tnrec_C * d T_s32) * X_s32) - (Param_cpst->K_C * State_cpst->X1)

Limit output value with minimum and maximum controller limits. If (Output value < Limit_cpst->Min_C) Then, Output_value = Limit_cpst->Min_C If (Output value > Limit_cpst->Max_C) Then, Output_value = Limit_cpst->Max_C

Calculated Output_value shall be stored to State_cpst->Y1. State_cpst->Y1 = Output_value

Current input value X_s32 shall be stored to State_cpst->X1. State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

This equation derives implementation : calc1 = Param_cpst->K_C * (1 + t_val) * X_s32 calc2 = Param_cpst->K_C * (1 - dT_s32 * Param_cpst->Tnrec_C + 2 * t_val) * State_ cpst->X1 calc3 = Param_cpst->K_C * t_val * State_cpst->X2 Output_value = State_cpst->Y1 + calc1 - calc2 + calc3 Where t_val = Param_cpst->Tv_C / dT_s32

Limit output value with minimum and maximum controller limits. If (Output value < Limit_cpst->Min_C) Then, Output_value = Limit_cpst->Min_C If (Output value > Limit_cpst->Max_C) Then, Output_value = Limit_cpst->Max_C

Calculated Output_value shall be stored to State_cpst->Y1. State_cpst->Y1 = Output_value

Old input value State_cpst->X1 shall be stored to State_cpst->X2 State_cpst->X2 = State_cpst->X1 Current input value X_s32 shall be stored to State_cpst->X1. State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

This equation derives implementation : calc1 = Param_cpst->K_C * (1 + dT_s32 * Param_cpst->Tnrec_C + t_val) * X_s32 calc2 = Param_cpst->K_C * (1 + 2 * t_val) * State_cpst->X1 calc3 = Param_cpst->K_C * t_val * State_cpst->X2 Output_value = State_cpst->Y1 + calc1 - calc2 + calc3 Where t_val = Param_cpst->Tv_C / dT_s32

Limit output value with minimum and maximum controller limits. If (Output value < Limit_cpst->Min_C) Then, Output_value = Limit_cpst->Min_C If (Output value > Limit_cpst->Max_C) Then, Output_value = Limit_cpst->Max_C

Calculated Output_value shall be stored to State_cpst->Y1. State_cpst->Y1 = Output_value

Old input value State_cpst->X1 shall be stored to State_cpst->X2 State_cpst->X2 = State_cpst->X1 Current input value X_s32 shall be stored to State_cpst->X1. State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

This equation derives implementation : Output_value = (TeQ * State_cpst->Y1) + K_s32 * (1 - TeQ) * ((X_s32 - State_cpst->X1) / dT) where TeQ = exp(-dT/T1) The result shall be Rounded towards Zero.

Efx_CalcTeQ_s32 shall be used for calculation of time equivalent parameter TeQ_s32.

If (Teq = 0), then DT1 controller follows Input value, Output_value = k_s32 * (X_s32 - State_cpst->X1) / dT

Calculated Output_value shall be stored to State_cpst->Y1. State_cpst->Y1 = Output_value

Current input value X_s32 shall be stored to State_cpst->X1. State_cpst->X1 = X_s32

Resolution of dT_s32 is 10-6 seconds per increment of 1 data representation unit

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_s16 << 16

The internal state of the DT1 element is stored as (Y1_s16 << 16)

Initialisation of input state variable X1. State_cpst->X1 = X1_s32

Output value = State_cpst->Y1 >> 16

Output value shall be normalized by 16 bit right shift of internal state variable.

Return value shall be limited by boundary values of the return data type.

Here is the list of implemented functions.

Parameter Switch decides which target value is selected. If Switch = TRUE, then Xa_s32 is selected. State_cpst->Switch_s8 is set to TARGET_A Return value = Xa_s32 If Switch = FALSE, then Xb_s32 is selected. State_cpst->Switch_s8 is set to TARGET_B Return value = Xb_s32

State_cpst->Dir_s8 hold direction information State_cpst->Dir_s8 shall be set to END to reset direction information in case of target switch.

Update limit structure Limit_cpst->Min_C = Min_s32 Limit_cpst->Max_C = Max_s32

Calculated value *P_ps32 = (K_s32 * X_s32) >> 16

Amplification factor is quantized with 1/216 per increment of 1 data representation unit

Efx_RampCalcSwitch routine has to be called before Efx_Ramp Calc

This equation derives implementation : Output_value = (TeQ_s32 * State_cpst->Y1) + K_s32 * (1 - TeQ_s32) * State_cpst->X1 where TeQ_s32 = exp (-dT/T1)

Efx_CalcTeQ_s32 shall be used for calculation of time equivalent parameter TeQ_s32 only if T1 > 0.

If (Teq = 0) then PT1 controller follows Input value, State_cpst->Y1 = k_s32 * State_cpst->X1

calculated Output_value and current input value shall be stored to State_cpst->Y1 and State_cpst->X1 respectively. State_cpst->Y1 = Output_value State_cpst->X1 = X_s32

Efx library shall not require initialization phase. A Library function may be called at the very first step of ECU initialization, e.g. even by the OS or EcuM, thus the library shall be ready.

Efx library shall not require a shutdown operation phase.

The Efx library shall be implemented in a way that the code can be shared among callers in different memory partitions.

Usage of macros should be avoided. The function should be de- clared as function or inline function. Macro #define should not be used.

A library function shall not call any BSW modules functions, e.g. the DET. A library function can call other library functions. Because a library function shall be re-entrant. But other BSW modules functions may not be re-entrant.

The library, written in C programming language, should conform to the MISRA C Standard. Please refer to SWS_BSW_00115 for more details.

Each AUTOSAR library Module implementation <library>*.c and <library>*.h shall map their code to memory sections using the AUTOSAR memory mapping mechanism.

All AUTOSAR library Modules should use the AUTOSAR data types (integers, boolean) instead of native C data types, unless this library is clearly identified to be compliant only with a platform.

All AUTOSAR library Modules should avoid direct use of compiler and platform specific keyword, unless this library is clearly identified to be compliant only with a platform. eg. #pragma, typeof etc.

The standardized common published parameters as required by SRS_BSW_00402 in the General Requirements on Basic Software Modules [REF] shall be published within the header file of this module and need to be provided in the BSW Module Description. The according module abbreviation can be found in the List of Basic Software Modules [REF].

If source code for caller and callee of Efx_GetVersionInfo is avail- able, the Efx library should realize Efx_GetVersionInfo as a macro defined in the mod- ule's header file.

The Efx library shall not have any configuration options that may affect the functional behavior of the routines. I.e. for a given set of input parameters, the outputs shall be always the same. For example, the returned value in case of error shall not be configurable.

Section 7.1 "Error Handling" of the document "General Specifica- tion of Basic Software Modules" describes the error handling of the Basic Software in detail. Above all, it constitutes a classification scheme consisting of five error types which may occur in BSW modules.

These requirements are not applicable to this specification.

Integral promotion has to be adhered to when implementing Efx services. Thus, to obtain maximal precision, intermediate results shall not be limited.

If the ramp state State_cpst->State_s32 has reached or crossed the target value X_s32 while the direction of the ramp had been RISING/FALLING, then set State_cpst->State_s32 = X_s32

Return-value shall be saturated to boundary values in the event of negative or positive overflow.

Return-value shall be saturated to boundary values in the event of negative or positive overflow.

Return-value shall be saturated to boundary values in the event of negative or positive overflow.

This routine computes the absolute value of a signed value: Return-value = |x_value|

Return-value shall be saturated to boundary values in the event of negative or positive overflow.

Here is the list of implemented functions.

[SWS_Efx_10005]

This routine makes a subtraction between the two arguments: Return-value = x_value - y_value.

Return-value shall be saturated to boundary values in the event of negative or positive overflow.

Here is the list of implemented functions.

[SWS_Efx_10010]

IF y_value is zero, the result is zero.

In other cases, Return-value = x_value mod y_value

The sign of the remainder is the same than the sign of x_value.

Here is the list of implemented functions.

Module Header File Imported Type Std Std_Types.h Std_VersionInfoType