MFl Library (Mfl)

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

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

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

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

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

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

Differential equation: Y = K * X

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

This routine computes PT1 controller output value using below difference equation

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

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

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

The routine initialises internal state variables of an I element.

This routine returns 'I' controllers output value.

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

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

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

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

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.

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

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

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

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

An increasing value and decreasing value is rate limited by maxdif

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

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

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

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

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

Calculates the sine of the argument.

Calculates the cosine of the argument.

Calculates the tangent of the argument.

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

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

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

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

The routine returns average value.

The routine returns average value of an array.

This service computes the length of a vector

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

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

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

Returns the internal state of the ramp element.

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.

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

Gets the current switch position of ramp switch function.

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

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 returns input value with specified delay time.

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 in ascending order & returns sorted array result via pointer

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

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.

This routine computes DT1 controller output value using differential equation

The routine initialises internal state variables of a DT1 element.

This routine returns 'DT1' controller's output value

This routine calculates time equivalent factor

This routine computes I controller output value using differential equation

Update limit structure

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

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

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

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

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

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

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

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

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

Update limit structure

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

Returns the version information of this library.

Returns the Float value for the corresponding Integer input.

Returns the Integer value for the corresponding floating point input.

Return the bit representation of the single point precision float value

Fast reciprocal square root of the operand (ValSqrt)

Fast cosine calculation

Fast sine calculation

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

System State Structure for PT1 controller routine

Structure definition for Ramp routine

Structure definition for Dead Time routine

Structure definition for Debouncing parameters

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 Debouncing state variables

The Mfl module shall provide the following files: • C files, Mfl_<name>.c used to implement the library. All C files shall be prefixed with 'Mfl_'.

Result = ValFloat * 2ValFixedExponent

The return value shall be saturated to the return type boundary values in the event of overflow or underflow.

If it is necessary to round the result of this equation, it is rounded toward zero.

Function ID[hex] Function prototype 0x01 uint16 Mfl_Cvrt_f32_u16(float32, sint16 ) 0x02 sint16 Mfl_Cvrt_f32_s16(float32, sint16 ) 0x03 uint32 Mfl_Cvrt_f32_u32(float32, sint16 ) 0x04 sint32 Mfl_Cvrt_f32_s32(float32, sint16 )

Result = ValFixedInteger * 2-ValFixedExponent

Function ID[hex] Function prototype 0x05 float32 Mfl_Cvrt_u16_f32( uint16, sint16 ) 0x06 float32 Mfl_Cvrt_s16_f32( sint16, sint16 ) 0x07 float32 Mfl_Cvrt_u32_f32( uint32, sint16 ) 0x08 float32 Mfl_Cvrt_s32_f32( sint32, sint16 )

If the argument is halfway between two integers, it is rounded away from zero. For example: 36.5 will be rounded to 37.00

Implemented difference equation: *P_pf32 = K_f32 * X_f32 1. Get 'P' output This routine can be realised using inline function.

Output value = *P_pf32

Yn= exp(-dT/T1) * Yn-1+ K(1- exp(-dT/T1)) * Xn-1 This derives implementation: Output_value = (TeQ_f32 * State_cpst->Y1) + K_f32 * (1 - TeQ_f32) * State_cpst->X1 where TeQ_f32 = exp (-dT/T1)

If (TeQ_f32 = 0) then PT1 controller follows Input value, State_cpst->Y1 = K_f32 * X_f32

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_f32 1. 'PT1' Set State Value This routine can be realised using inline function.

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_f32

Initialisation of input state variable X1. State_cpst->X1 = X1_f32. 1. Calculate time equivalent Value This routine can be realised using inline function.

TeQ_f32 = exp(-T1rec_f32 * dT_f32) 1. Calculate an approximate time equivalent Value This routine calculates approximate time equivalent and can be realised using inline function

Output value = State_cpst->Y1

Yn= exp(-dT/T1) * Yn-1+ K * (1- exp(-dT/T1)) * ((Xn-1 - Xn-2) / dT) This derives implementation: Output_value = (TeQ_f32 * State_cpst->Y1) + K_f32 * (1 - TeQ_f32) * ((State_cpst->X1 - State_cpst->X2) / dT_f32) where TeQ_f32 = exp(-dT_f32/T1)

If (TeQ_f32 = 0) then DT1 controller follows Input value, Output_value = K_f32 * (X_f32 - State_cpst->X1) / dT_f32

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_f32 shall be stored to State_cpst->X1. State_cpst->X1 = X_f32 1. 'DT1' Controller - Type2

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_f32

Initialisation of input state variables X1 and X2. State_cpst->X1 = X1_f32 State_cpst->X2 = X2_f32 1. Set 'DT1' State Value - Type2 This routine can be realised using inline function.

Output value = State_cpst->Y1 1. Get 'DT1' output - Type2 This routine can be realised using inline function.

Yn= K(1+Tv/dT) * Xn- K(Tv/dT) * Xn-1 This derives implementation: Output_value = (Param_cpst->K_C * (1+ Param_cpst->Tv_C/dT_f32) * X_f32) - (Param_cpst->K_C * (Param_cpst->Tv_C/dT_f32) * State_cpst->X1)

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

Current input value X_f32 shall be stored to State_cpst->X1. State_cpst->X1 = X_f32 1. PD Set State Value This routine can be realised using inline function.

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_f32

Initialisation of input state variable X1. State_cpst->X1 = X1_f32 1. Set 'PD' Parameters This routine can be realised using inline function.

Initialisation of amplification factor. Param_cpst->K_C = K_f32

Initialisation of lead time state variable Param_cpst->Tv_C = Tv_f32 1. Get 'PD' output This routine can be realised using inline function.

Output value = State_cpst->Y1

Yn= Yn-1 + K * dT * Xn-1 This derives implementation: Output_value = State_cpst->Y1 + K_f32 * dT_f32 * 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_f32 1. 'I' Controller with limitation

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_f32

Initialisation of input state variable X1. State_cpst->X1 = X1_f32 1. Get 'I' output This routine can be realised using inline function.

Output value = State_cpst->Y1

Yn= Yn-1+ K * Xn- K * (1 - dT/Tn) * Xn-1 This derives implementation: Output_value = State_cpst->Y1 + (Param_cpst->K_C * X_f32) - (Param_cpst->K_C * (1 - Param_cpst->Tnrec_C * dT_f32) * State_cpst->X1)

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

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

Yn= Yn-1 + K * (1 + dT/Tn) * Xn - K * Xn-1 This derives implementation: Output_value = State_cpst->Y1 + (Param_cpst->K_C * (1 + Param_cpst->Tnrec_C * d T_f32) * X_f32) - (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_f32 shall be stored to State_cpst->X1. State_cpst->X1 = X_f32

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_f32

Initialisation of input state variable X1. State_cpst->X1 = X1_f32 1. Set 'PI' Parameters This routine can be realised using inline function.

Initialisation of amplification factor. Param_cpst->K_C = K_f32

Initialisation of reciprocal follow up time state variable Param_cpst->Tnrec_C = Tnrec_f32 1. Get 'PI' output This routine can be realised using inline function.

Output value = State_cpst->Y1

Yn=Yn-1+ K * (1 + Tv/dT) * Xn- K *(1 - dT/Tn + 2Tv/dT) * Xn-1 + K * (Tv/dT) * Xn-2 This derives implementation: calc1 = Param_cpst->K_C * (1 + t_val) * X_f32 calc2 = Param_cpst->K_C * (1 - dT_f32 * 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_f32

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_f32 shall be stored to State_cpst->X1. State_cpst->X1 = X_f32 1. 'PID' Controller - Type1 with limitation (Implicit type)

Yn = Yn-1 + K * (1 + dT/Tn+ Tv/dT) * Xn- K *(1 + 2Tv/dT) * Xn-1+ K * (Tv/dT) * Xn-2 This derives implementation: calc1 = Param_cpst->K_C * (1 + dT_f32 * Param_cpst->Tnrec_C + t_val) * X_f32 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_f32

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_f32 shall be stored to State_cpst->X1. State_cpst->X1 = X_f32 1. 'PID' Controller - Type2 with limitation (Explicit type)

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_f32

Initialisation of input state variable X1. State_cpst->X1 = X1_f32 Initialisation of input state variable X2. State_cpst->X2 = X2_f32 1. Set 'PID' Parameters This routine can be realised using inline function.

Initialisation of amplification factor. Param_cpst->K_C = K_f32

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

Initialisation of reciprocal follow up time state variable Param_cpst->Tnrec_C = Tnrec_f32 1. Get 'PID' output This routine can be realised using inline function.

Output value = State_cpst->Y1

ValAbs = | ValValue |

ValSign = 1, ValValue > 0.0

ValSign = 0, ValValue == 0.0

ValSign = -1, ValValue < 0.0

ValMax = ValValue1, ValValue1  ValValue2 ValMax = ValValue2, ValValue1 < ValValue2

Min = Value1, Value1  Value2 Min = Value2, Value1 > Value2

if ( newval > oldval ) and (( newval - oldval ) > maxdif ) Result = oldval + maxdif else if ( newval < oldval ) and (( oldval - newval ) > maxdif ) Result = oldval - maxdif else Result = newval

newVal = lowLim, val  lowLim newVal = upLim, val  upLim newVal = val, lowLim < val < upLim

ValResult = ValBaseValExp

If ValExp = 0, and ValBase = 0, ValResult = 1, ( 00 = 1) If ValBase = 0 and ValExp <> 0, ValResult = 0, ( 0ValExp = 0)

If ValBase and ValExp are having maximum value of type float32, the return value will be toward positive infinity.

ValSqrt = ValValue1/2

ValValue shall be passed as positive value. (ValValue  0)

ValExp = eValValue

Call the function with input value in the range [-24PI, +24PI]

ValLog = loge(ValValue)

ValValue shall be passed as > 0 value.

Result: result = sine ( value )

Call the function with input value in the range [-24PI, +24PI]

Result: result = cosine ( value )

Call the function with input value in the range [-24PI, +24PI]

Result: result = tangent( value )

Call the function with input value in the range [-24PI, +24PI]

If the argument is zero, then the result is a zero.

Range of the value shall be [-1, +1]

Range of the value shall be [-1, +1]

If the argument is zero, then the result is a zero with the same sign as the argument.

If the argument is zero, then the result is a zero with the same sign as the argument.

Z = X2_f32 / X1_f32 if (Z > 1) Then Result = Z / (1.0 + (0.28 * Zˆ2)) if (Z < 1) Then Result = (pi / 2) - (Z / (Zˆ2 + 0.28))

Output = (Value1 + Value2 ) / 2

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

This service computes the length of a vector: Result = square_root ( x_value * x_value + y_value * y_value)

If ramp direction is rising then ramp increases a value with slope * dT_f32 if (State_cpst->Dir_s8 == RISING) State_cpst->State_f32 = State_cpst->State_f32 + (Param_cpcst->SlopePos_f32 * dT_ f32)

If ramp direction is falling then ramp decreases a value with slope * dT_f32 if (State_cpst->Dir_s8 == FALLING) State_cpst->State_f32 = State_cpst->State_f32 - (Param_cpcst->SlopeNeg_f32 * dT_ f32)

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_f32 > X_f32) then State_cpst->Dir_s8 = FALLING If(State_cpst->State_f32 < X_f32) then State_cpst->Dir_s8 = RISING If(State_cpst->State_f32 == X_f32) then State_cpst->Dir_s8 = END

Ramp direction is initialised with END value. User has no possibility to change or modify ramp direction. State_cpst->Dir_s8 = END For example: ramp direction states: RISING = 1, FALLING = -1, END = 0

Sets positive and negative ramp slopes. Param_cpst->SlopePos_f32 = SlopePosVal_f32 Param_cpst->SlopeNeg_f32 = SlopeNegVal_f32

Return Value = State_cpcst->State_f32

If target value changes to a value contrary to current ramp direction and ramp has not reached its old target value then ramp state jumps to new target value immediately. State_cpst->State_f32 = X_f32 State_cpst->Dir_s8 = END Otherwise the previous values of State_cpst->Dir_s8 and State_cpst->State_f32 should be kept.

Switch decides target to select. If (State_cpst->Switch_s8 == TARGET_A), target = Xa_f32 If (State_cpst->Switch_s8 == TARGET_B), target = Xb_f32

State_cpst->Dir_s8 holds direction information Ramp direction status: RISING, FALLING, END

If ramp is active then ramp will change to reach selected target with defined slope. if (State_cpst->Dir_s8 == RISING) then State_cpst->State_f32 = State_cpst->State_f32 + (Param_cpcst->SlopePos_f32 * dT_f32) else if (State_cpst->Dir_s8 == FALLING) then State_cpst->State_f32 = State_cpst->State_f32 - (Param_cpcst->SlopeNeg_f32 * dT_f32) else if (State_cpst->Dir_s8 == END) State_cpst->State_f32 = target value which is decided by State_cpst->Switch_s8.

Once ramp value reaches the selected target value, the ramp direction status is switched to END. State_cpst->Dir_s8 == END

If the ramp has reached its destination and no change of switch occurs, the output value follows the actual target value. If(State_cpst->State_f32 == target value) Return_value = Xa_f32 (if State_cpst->Switch_s8 is TARGET_A) Return_value = Xb_f32 (if State_cpst->Switch_s8 is TARGET_B)

Calculated ramp value shall be stored to State_cpst->State_f32 variable.

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)

Return value is TRUE if input is greater then center plus halfDelta switching point.

Return value is FALSE if input is less then center minus halfDelta switching point.

Return value is former state value if input is in the range of halfDelta around the center switching point

Return value is TRUE if input is greater then right switching point.

Return value is FALSE if input is less then left switching point.

Return value is former state value if input is between left and right switching points

Return value is TRUE if input is greater then right switching point.

Return value is FALSE if input is less then right switching point minus delta.

Return value is former state value if input is between right switching points and right minus delta.

Return value is TRUE if input is greater then left switching point plus delta.

Return value is FALSE if input is less then left switching point.

Return value is former state value if input is between left switching points and left plus delta.

Buffer data stores input samples hence reproduced output signal will reduce samples in case high delay time.

Buffer size shall be configured as per the delay time range requirement.

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

If transition is from Low to High, then use Param->TimeLowHigh as debouncing time otherwise use Param->TimeHighLow

State->Timer is incremented with sample time for debouncing input signal. Once reached to the set period, old state is updated with X. State->Timer += dT; If(State ->Timer  TimePeriod) 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

State->Timer = 0

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

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

Initialisation of state variable State_cpst ->State_f32 = Val_f32

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

Returns the median value of sorted array in case of N is even. Result = (Sorted_array[N/2] + Sorted_array[(N/2) - 1] ) / 2 For example: Sorted_array[4] = [8.0, 10.0, 15.0, 42.0] Result = (15.0 + 10.0) / 2.0 = 12.5

Returns the median value of sorted array in case of N is odd. Return_Value = Sorted_array [N/2] = 15 For example: Sorted_array[5] = [8.0, 10.0, 15.0, 42.0, 88.0] Result = 15.0

In above calculation, N/2 shall be rounded off towards 0. 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.

Yn= exp(-dT/T1) * Yn-1+ K * (1- exp(-dT/T1)) * ((Xn - Xn-1) / dT) This derives implementation: Output_value = (TeQ_f32 * State_cpst->Y1) + K_f32 * (1 - TeQ_f32) * ((X_f32 - State_ cpst->X1) / dT_f32) where TeQ_f32 = exp(-dT_f32/T1)

If (TeQ_f32 = 0) then DT1 controller follows Input value, Output_value = K_f32 * (X_f32 - State_cpst->X1) / dT_f32

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

Current input value X_f32 shall be stored to State_cpst->X1. State_cpst->X1 = X_f32x 1. Set 'DT1' State Value - Type1 This routine can be realised using inline function.

Initialisation of output state variable Y1. State_cpst->Y1 = Y1_f32

Initialisation of input state variable X1. State_cpst->X1 = X1_f32 1. Get 'DT1' output - Type1 This routine can be realised using inline function.

Output value = State_cpst->Y1

TeQApp_f32 = 1 - (T1rec_f32 * dT_f32) 1. Get 'PT1' output This routine can be realised using inline function.

Yn= Yn-1 + K * dT * Xn-1 This derives implementation: Output_value = State_cpst->Y1 + K_f32 * dT_f32 * State_cpst->X1

Limit output value with maximum and minimum 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_f32 1. Set limits for controllers

Update limit structure Limit_cpst->Min_C = Min_f32 Limit_cpst->Max_C = Max_f32

Yn= Yn-1+ K * Xn- K * (1 - dT/Tn) * Xn-1 This derives implementation: Output_value = State_cpst->Y1 + (Param_cpst->K_C * X_f32) - (Param_cpst->K_C * (1 - Param_cpst->Tnrec_C * dT_f32) * State_cpst->X1)

Limit output value with maximum and minimum 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_f32 shall be stored to State_cpst->X1. State_cpst->X1 = X_f32

Yn= Yn-1 + K * (1 + dT/Tn) * Xn - K * Xn-1 This derives implementation: Output_value = State_cpst->Y1 + (Param_cpst->K_C * (1 + Param_cpst->Tnrec_C * d T_f32) * X_f32) - (Param_cpst->K_C * State_cpst->X1)

Limit output value with maximum and minimum 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_f32 shall be stored to State_cpst->X1. State_cpst->X1 = X_f32 1. Set 'PI' State Value This routine can be realised using inline function.

Yn=Yn-1+ K * (1 + Tv/dT) * Xn- K *(1 - dT/Tn + 2Tv/dT) * Xn-1 + K * (Tv/dT) * Xn-2 This derives implementation: calc1 = Param_cpst->K_C * (1 + t_val) * X_f32 calc2 = Param_cpst->K_C * (1 - dT_f32 * 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_f32

Limit output value with maximum and minimum 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_f32 shall be stored to State_cpst->X1. State_cpst->X1 = X_f32 1. 'PID' Controller - Type2 (Explicit type)

Yn = Yn-1 + K * (1 + dT/Tn+ Tv/dT) * Xn- K *(1 + 2Tv/dT) * Xn-1+ K * (Tv/dT) * Xn-2 This derives implementation: calc1 = Param_cpst->K_C * (1 + dT_f32 * Param_cpst->Tnrec_C + t_val) * X_f32 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_f32

Limit output value with maximum and minimum 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_f32 shall be stored to State_cpst->X1. State_cpst->X1 = X_f32 1. Set 'PID' State Value This routine can be realised using inline function.

If the argument is zero, then the result is a zero.

Range of the value shall be [-1, +1]

Range of the value shall be [-1, +1]

If the argument is zero, then the result is a zero with the same sign as the argument.

If the x coordinate is zero, then check if(y > 0.0) then Return PI/2 if(y = 0.0) then Return Zero if(y < 0.0) then Return -PI/2

Z = y / x if (|Z| < 1) Then Result = Z / (1.0 + (0.28 * Zˆ2)) if (x < 0.0f) Then Result = (y < 0.0f) ? Result - PI : Result + PI Else Result = (pi / 2) - (Z / (Zˆ2 + 0.28)) if ( y < 0.0f ) Result = Result - PI;

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

Update limit structure Limit_cpst->Min_C = Min_f32 Limit_cpst->Max_C = Max_f32 1. Set 'I' State Value This routine can be realised using inline function.

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

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.

Mfl_RampCalcSwitch has to be called before Mfl_RampCalc routine

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

Mfl library shall not require a shutdown operation phase.

The Mfl 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.

Each AUTOSAR library Module implementation <library>*.c, that uses AUTOSAR integer data types and/or the standard return, shall include the header file Std_Types.h.

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 Mfl_GetVersionInfo is avail- able, the Mfl library should realize Mfl_GetVersionInfo as a macro defined in the mod- ule's header file.

The functions shall not call the DET for error notification.

The Mfl 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.

Error detection: The validity of the parameters passed to library functions must be checked at the application level, there is no error detection or report- ing within the library function. The library functions are required return a predefined but mathematically senseless value when they are called with invalid parameters. Warning, this strategy has the unsound consequence of masking errors throughout the software development process. All the invalid input cases shall be listed in the SWS specifying a predefined function return value that is not configurable. This value is dependant of the function and the error case so it is determined case by case. If values passed to the routines are not valid and out of the function specification, then such error are not detected.

can be found here:[10](ISO/IEC 9899:1990 Programming Language - C) Mfl_Sin_f32(float32) <=> sinf(float) Mfl_Cos_f32(float32) <=> cosf(float) Mfl_Tan_f32(float32) <=> tanf(float) Mfl_Exp_f32(float32) <=> expf(float) Mfl_Log_f32(float32) <=> logf(float) Mfl_ArcSin_f32(float32) <=> asinf(float) Mfl_ArcCos_f32(float32) <=> acosf(float) Mfl_ArcTan_f32(float32) <=> atanf(float) Mfl_ArcTan2_f32(float32) <=> atan2f(float) Mfl_Hypot_f32f32_f32 <=> hypotf

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.

If the ramp state State_cpst->State_f32 has reached or crossed the target value X_ f32 while the direction of the ramp had been RISING/FALLING, then set State_cpst- >State_f32 = X_f32.

The result shall be round ties to even.

Function ID[hex] Function prototype 0xD1 float32 Mfl_IntToFloatCvrt_u8_f32(uint8) 0xD2 float32 Mfl_IntToFloatCvrt_s8_f32(sint8) 0xD3 float32 Mfl_IntToFloatCvrt_u16_f32(uint16) 0xD4 float32 Mfl_IntToFloatCvrt_s16_f32(sint16) 0xD5 float32 Mfl_IntToFloatCvrt_u32_f32(uint32) 0xD6 float32 Mfl_IntToFloatCvrt_s32_f32(sint32) 0xD9 float32 Mfl_IntToFloatCvrt_u64_f32(uint64) 0xDA float32 Mfl_IntToFloatCvrt_s64_f32(sint64)

The return value shall be saturated to the return type boundary values in the event of overflow or underflow.

The result shall be rounded toward zero.

Function ID[hex] Function prototype 0xCB uint8 Mfl_FloatToIntCvrt_f32_u8(float32) 0xCC sint8 Mfl_FloatToIntCvrt_f32_s8(float32) 0xCD uint16 Mfl_FloatToIntCvrt_f32_u16(float32) 0xCE sint16 Mfl_FloatToIntCvrt_f32_s16(float32) 0xCF uint32 Mfl_FloatToIntCvrt_f32_u32(float32) 0xD0 sint32 Mfl_FloatToIntCvrt_f32_s32(float32) 0xD7 uint64 Mfl_FloatToIntCvrt_f32_u64(float32) 0xD8 sint64 Mfl_FloatToIntCvrt_f32_s64(float32)

If the input is +/- Infinity, then the output shall be limited to target type boundaries (max/min) after the conversion.

Service name: Mfl_DivLim_f32 Syntax: Mfl_Div_St Mfl_DivLim_f32(float32 x_f32, float32 y_f32, float32 min_f32, float32 max_f32, float32* Result) Service ID[hex]: 0xDC Sync/Async: Synchronous Reentrancy: Reentrant x_f32 dividend y_f32 divisor min_f32 minimum limit, min_f32 shall not be strictly greater than max_f32 Parameters (in): max_f32 maximum limit, max_f32 shall not be strictly lower than min_f32 Parameters (inout): None Parameters (out): Result Pointer to the result Return value: Mfl_Div_St Returns status of division E_SUCCESS: Division operation successful E_DIVBYZERO: Divide by Zero E_INVALID: Invalid operation Description: Divides x_f32 by y_f32 and limits the result within the min_f32 and max_f32 value. Available via: Mfl.h

Returns E_SUCCESS, in case of the following scenarios,if the dividend and divisor are finite then,Result = X_f32 / Y_f32 and the sign of result is the exclusive OR of the operands' signs. IF(*Result > max_f32) *Result = max_f32 ELSE IF(*Result < min_f32) *Result = min_f32 If the dividend is +/-Infinity and the divisor is finite number then the result shall be saturated to max/min based on the sign of the result which is the exclusive OR of the operands' signs. If the divisor is Infinity and dividend is finite number then the result shall be zero and the sign of result is the exclusive OR of the operands' signs.

Returns E_INVALID, if there is an invalid operation and the result of the IEEE754 divi- sion operation is NaN (not a number). According to IEEE 754 the results of 0/0 and (+/- 1 )/(+/- 1 ) are invalid. In these cases the function result shall remain at its initial value.

Returns E_DIVBYZERO, if the divisor is zero and the dividend is a finite non-zero num- ber, the result shall be max/min based on the sign of the result which is the exclusive OR of the operands' signs.

If the input is NaN, then the output of the conversion shall be zero.

Service name: Mfl_Mod_f32 Syntax: Mfl_Mod_St_Type Mfl_Mod_f32(float32 x_f32, float32 y_f32, float32* Result) Service ID[hex]: 0xDB Sync/Async: Synchronous Reentrancy: Reentrant x_f32 dividend Parameters (in): y_f32 divisor Parameters (inout): None Parameters (out): Result Pointer to the Result Return value: Mfl_Mod_St_Type Returns status of modulus operation E_SUCCESS: Mod operation success E_INVALID: Invalid Operation Description: This routine returns the value x_f32 - (n*y_f32), for some integer n such that, if y_ f32 is nonzero, the result has the same sign as x_f32 and magnitude less than the magnitude of y_f32. Available via: Mfl.h

Returns E_SUCCESS, in case of the following scenarios, if the dividend and divisor is finite then, *Result = x_f32 % y_f32 and the sign of result shall be same as sign of divdend. - If the dividend is +/-0 and the divisor is finite number then the result shall be +/-0. - If the dividend is finite number and divisor is +/-Infinity then the dividend shall be return as the result and the sign of result shall be same as that of the dividend.

Returns E_INVALID, if there is an invalid operation and the result of the operation shall be NaN (not a number). The operations considered as invalid in the following scenarios: - If the divisor is zero - If dividend is +/- infinity - If dividend or divisor is NaN - mod(0, 0) or mod(+/ 1 , +/ 1 )

Calculate an approximation of the reciprocal of the square root of ValValue (1/sqrt(ValValue)). The accuracy of the result is no less than 6.75 bits, and therefore always within +/- 1 % of the accurate result. This instruction can be used to implement a floating-point square root function in soft- ware using the Newton-Raphson iterative method.