IFl Library (Ifl)

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

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

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

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

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

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

Returns the version information of this library.

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.

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.

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.

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.

Structure used for data point search for index and ratio

The Ifl module shall provide the following files: • C files, Ifl_<name>.c used to implement the library. All C files shall be prefixed with 'Ifl_'. Implementation & grouping of routines with respect to C files is recommended as per below options and there is no restriction to follow the same. Option 1 : <Name> can be function name providing one C file per function, eg.: Ifl_IntIpoMap_f32f32_f32.c etc. Option 2 : <Name> can have common name of group of functions: • 2.1 Group by object family: eg.:Ifl_IpoCur.c, Ifl_DPSearch.c • 2.2 Group by routine family: eg.: Ifl_IpoMap.c • 2.3 Group by method family: eg.: Ifl_Ipo.c etc. • 2.4 Group by other methods: (individual grouping allowed) Option 3 : <Name> can be removed so that single C file shall contain all Ifl functions, eg.: Ifl.c. Using above options gives certain flexibility of choosing suitable granularity with re- duced number of C files. Linking only on-demand is also possible in case of some options.

Ifl_DPResultF32_Type structure shall not be read/write/modified by the user directly. Only Ifl routines shall have access to this structure.

Returned Index shall be the lowest index for which (X_array[index] < Xin < X_array[index + 1]). If (X_array[0] <=Xin <= X_array[N-1]), then returned Index shall be the lowest index. dpResult->Index=indexdpResult->Ratio=(Xin-X_array[index]) / (X_array[index + 1] - X_ array[index]) dpResult ->Index = index dpResult ->Ratio = (Xin - X_array[index]) / (X_array [index+1] - X_array [index])

If the input value matches with one of the distribution array values, then return respective index and ratio as 0.0. If Input Xin == X_array[index], then dpResult ->Index = index (Index of the set point) dpResult ->Ratio = 0.0

If (Xin < X_array[0]), then return first index of an array and ratio = 0.0 dpResult ->Index = 0 dpResult ->Ratio = 0.0

If (Xin > X_array[N-1]), then return last index of an array and ratio = 0.0 dpResult ->Index = N - 1 dpResult ->Ratio = 0.0

The minimum value of N shall be 1

If X_array[Index+1] == X_array[Index], then the Ratio shall be zero. dpResult->Ratio = 0.0

This routine returns index and ratio through the structure of type Ifl_ DPResultF32_Type

index = dPResult->Index if dPResult->Ratio == 0.0 Result = Val_array[index] else Result = Val_array[index] + (Val_array[index+1] - Val_array[index]) * dpResult->Ratio

Based on searched indices and ratios information using the Ifl_ DPSearch_f32 routine, this routine calculates and returns the interpolation result for map. BaseIndex = dpResultX->Index * num_value + dpResultY->Index if (dpResultX->Ratio == 0) if (dpResultY->Ratio == 0) Result = Val_array [BaseIndex] else LowerY = Val_array [BaseIndex] UpperY = Val_array [BaseIndex + 1] Result = LowerY + (UpperY - LowerY) * dpResultY->Ratio else if (dpResultY->Ratio == 0) LowerX = Val_array [BaseIndex] UpperX = Val_array [BaseIndex + num_value] Result = LowerX + (UpperX - LowerX) * dpResultX->Ratio else LowerY = Val_array [BaseIndex] UpperY = Val_array [BaseIndex + 1] LowerX = LowerY + (UpperY - LowerY) * dpResultY->Ratio LowerY = Val_array [BaseIndex + num_value] UpperY = Val_array [BaseIndex + num_value + 1] UpperX = LowerY + (UpperY - LowerY) * dpResultY->Ratio Result = LowerX + (UpperX - LowerX) * dpResultX->Ratio

Result = Value1 + (Coef * (Value2 - Value1))

index = minimum value of integer index if (X_array[index] < Xin < X_array[index+1]) RatioX = (Xin - X_array[index]) / (X_array [index+1] - X_array [index]) Result = Val_array[index] + (Val_array[index+1] - Val_array[index])*RatioX

If the input value matches with one of the distribution array values, then result will be the respective Y array element indicated by the index. If (Xin == X_array[index]), Result = Val_array[index]

If Xin < X_array[0], then Result = Val_array[0]

If Xin > X_array[N-1], then Result = Val_array[N-1]

The minimum value of N shall be 1

indexX = minimum value of index if (X_array[indexX] < Xin < X_ array[indexX+1]) indexY = minimum value of index if (Y_array[indexY] < Yin < Y_array[indexY+1]) RatioX = (Xin - X_array[indexX]) / (X_array [indexX+1] - X_array [indexX]) RatioY = (Yin - Y_array[indexY]) / (Y_array [indexY+1] - Y_array [indexY]) BaseIndex = IndexX * Ny + indexY LowerY = Val_array [BaseIndex] UpperY = Val_array [BaseIndex + 1] LowerX = LowerY + (UpperY - LowerY) * RatioY LowerY = Val_array [BaseIndex + Ny] UpperY = Val_array [BaseIndex + Ny + 1] UpperX = LowerY + (UpperY - LowerY) * RatioY Result = LowerX + (UpperX - LowerX) * RatioX

If (Xin == X_array[indexX]) and (Y_array[indexY] < Yin < Y_ar- ray[indexY+1]) Result = Val_array [BaseIndex] + (Val_array [BaseIndex+1] - Val_array[BaseIndex]) * RatioY

If (Yin == Y_array[indexY]) and (X_array[indexX] < Xin < X_ar- ray[indexX+1]) Result = Val_array [BaseIndex] + (Val_array [BaseIndex+Ny] - Val_array[BaseIndex]) * RatioX

If (Xin == X_array[indexX]) and (Yin == Y_array[indexY]) Result = Val_array [BaseIndex]

If Xin < X_array[0], then indexX = 0, RatioX = 0.0

If Xin > X_array[Nx-1], then indexX = Nx - 1, RatioX = 0.0

If Yin < Y_array[0], then indexY = 0, RatioY = 0.0

If Yin > Y_array[Ny-1], then indexY = Ny - 1, RatioY = 0.0

The minimum value of N shall be 1

Record layout Name Element1 Element2 Element3 Element4 Element5 Distr_f32 uint32 N float32 X[] Curve_f32 float32 Val[] Map_f32 float32 Val[] Cub_f32 float32 Val[] IntCurve_f32_f32 uint32 N float32 X[] float32 Val[] IntMap_f32f32_ f32 uint32 Nx uint32 Ny float32 X[] float32 Y[] float32 Val[]

Do not call this routine until you have searched the axis using the Ifl_DPSearch routine. Only then it is ensured that the search result (Ifl_DPResultF32_ Type) contains valid data and is not used uninitialized.

Do not call this routine until you have searched the axis using the Ifl_DPSearch routine. Only then it is ensured that the search result (Ifl_DPResultF32_ Type) contains valid data and is not used uninitialized.

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

Ifl library shall not require a shutdown operation phase.

The Ifl 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 can call other library functions because all library functions shall be re-entrant. A library function shall not call any BSW modules func- tions, e.g. the DET.

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 Ifl_GetVersionInfo is avail- able, the Ifl library should realize Ifl_GetVersionInfo as a macro defined in the module's header file.

The functions shall not call the DET for error notification.

The Ifl library shall not have any configuration options that may af- fect 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: Function should check at runtime (both in produc- tion and development code) the value of input parameters, especially cases where erroneous value can bring to fatal error or unpredictable result, if they have the values allowed by the function specification. All the error cases shall be listed in SWS and the function should return a specified value (in SWS) 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.

If input value is less than first distribution entry then first value of the distribution array shall be returned or used in the interpolation routines. If input value is greater than last distribution entry then last value of the distribution array shall be returned or used in the interpolation routines.

Axis distribution passed to Ifx routines shall have normal monotony sequence.

Spezifikationsanforderung SWS_Ifl_00223.

These requirements are not applicable to this specification.

[SWS_Ifl_00226] ⌈Based on searched indices and ratios information using the Ifl_ DPSearch_f32 routine, this routine calculates and returns the interpolation result for 3D cuboids. The axis order memory representation is [z][x][y]. This is the column-major orientation COLUMN_DIR from ASAM standard. The first axis z specifies the selected slice. Implementation: Linear interpolation along x-axis between the result of two 2D interpolations between neighbouring X/Y Maps. num_slice = num_x * num_y if(dpResultZ->Ratio==0.0) Result=Ifl_IpoMap_f32 (dpResultX, dpResultY, num_y, Val_array[num_slice * dpResultZ->Index]) else LowerXY=Ifl_IpoMap_f32 (dpResultX, dpResultY, num_y, Val_array[num_slice * dpRe- sultZ ->Index]) UpperXY=Ifl_IpoMap_f32 (dpResultX, dpResultY, num_y, Val_array[num_slice * dpRe- sultZ ->Index + 1]) Result=Ifl_Interpolate_f32 (LowerXY, UpperXY, dpResultZ->Ratio)⌋

[SWS_Ifl_00228] ⌈index=dpResult->Index if dpResult->Ratio==0.0 Result=Val_array[index] else Result=Val_array[index] + (Val_array[index + 1]- Val_array[index]) * dpResult->Ratio⌋ Here is the list of implemented routines:

[SWS_Ifl_00229] ⌈ Routine ID[hex] Routine prototype 0x013 float32 Ifl_IpoCur_u8_f32 ( const Ifl_DPResultF32_Type* dpResult, const uint8* Val_array) 0x014 float32 Ifl_IpoCur_u16_f32 ( const Ifl_DPResultF32_Type* dpResult, const uint16* Val_array) 0x015 float32 Ifl_IpoCur_s8_f32 ( const Ifl_DPResultF32_Type* dpResult, const sint8* Val_array) 0x016 float32 Ifl_IpoCur_s16_f32 ( const Ifl_DPResultF32_Type* dpResult, const sint16* Val_array) ⌋

[SWS_Ifl_00231] ⌈Based on searched indices and ratios information using the Ifl_ DPSearch_f32 routine, this routine calculates and returns the interpolation result for map. BaseIndex = dpResultX->Index * num_value + dpResultY->Index if (dpResultX->Ratio == 0.0) if (dpResultY->Ratio == 0.0) Result = Val_array [BaseIndex] else LowerY = Val_array [BaseIndex] UpperY = Val_array [BaseIndex + 1] Result = LowerY + (UpperY - LowerY) * dpResultY->Ratio else if (dpResultY->Ratio == 0.0) LowerX = Val_array [BaseIndex] UpperX = Val_array [BaseIndex + num_value] Result = LowerX + (UpperX - LowerX) * dpResultX->Ratio else LowerY = Val_array [BaseIndex] UpperY = Val_array [BaseIndex + 1] LowerX = LowerY + (UpperY - LowerY) * dpResultY->Ratio LowerY = Val_array [BaseIndex + num_value] UpperY = Val_array [BaseIndex + num_value + 1] UpperX = LowerY + (UpperY - LowerY) * dpResultY->Ratio Result = LowerX + (UpperX - LowerX) * dpResultX->Ratio⌋ Here is the list of implemented routines.

[SWS_Ifl_00232] ⌈ Routine ID[hex] Routine prototype 0x018 float32 Ifl_IpoMap_u8_f32 ( const Ifl_DPResultF32_Type* dpResultX, const Ifl_DPResultF32_Type* dpResultY, uint32 num_value, const uint8* Val_array) 0x019 float32 Ifl_IpoMap_u16_f32 ( const Ifl_DPResultF32_Type* dpResultX, const Ifl_DPResultF32_Type* dpResultY, uint32 num_value, const uint16* Val_array) 0x01A float32 Ifl_IpoMap_s8_f32 (const Ifl_DPResultF32_Type* dpResultX, const Ifl_DPResultF32_Type* dpResultY, uint32 num_value, const sint8* Val_array) 0x01B float32 Ifl_IpoMap_s16_f32 (const Ifl_DPResultF32_Type* dpResultX, const Ifl_DPResultF32_Type* dpResultY, uint32 num_value, const sint16* Val_array) ⌋

[SWS_Ifl_00234] ⌈Based on searched indices and ratios information using the Ifl_ DPSearch_f32 routine, this routine calculates and returns the interpolation result for 3D cuboids. The axis order memory representation is [z][x][y]. This is the column-major orientation COLUMN_DIR from the ASAM standard. The first axis z specifies the selected slice. Implementation: Linear interpolation along x-axis between the result of two 2D interpolations between neighboring X/Y Maps. num_slice = num_x*num_y if (dpResultZ->Ratio == 0.0) Result = Ifl_IpoMap_<InTypeMn>_f32 (dpResultX, dpResultY, num_y, Val_array[num_ slice*dpResultZ->Index]) else LowerXY = Ifl_IpoMap_<InTypeMn>_f32 (dpResultX, dpResultY, num_y, Val_ar- ray[num_slice*dpResultZ->Index]) UpperXY = Ifl_IpoMap_<InTypeMn>_f32 (dpResultX, dpResultY, num_y, Val_ar- ray[num_slice*dpResultZ->Index + 1]) Result = Ifl_Interpolate_f32 (LowerXY, UpperXY, dpResultZ->Ratio)⌋ Here is the list of implemented routines.

[SWS_Ifl_00235] ⌈ Routine ID[hex] Routine prototype 0x01C float32 Ifl_IpoCub_u8_f32 ( const Ifl_DPResultF32_Type* dpResultX, const Ifl_DPResultF32_Type* dpResultY, const Ifl_DPResultF32_Type* dpResultZ, uint16 num_x, uint16 num_y, const uint8* Val_array) 0x01D float32 Ifl_IpoCub_u16_f32 ( const Ifl_DPResultF32_Type* dpResultX, const Ifl_DPResultF32_Type* dpResultY, const Ifl_DPResultF32_Type* dpResultZ, uint16 num_x, uint16 num_y, const uint16* Val_array) 0x01E float32 Ifl_IpoCub_s8_f32 (const Ifl_DPResultF32_Type* dpResultX, const Ifl_DPResultF32_Type* dpResultY, const Ifl_DPResultF32_Type* dpResultZ, uint16 num_x, uint16 num_y, const sint8* Val_array) 0x01F float32 Ifl_IpoCub_s16_f32 (const Ifl_DPResultF32_Type* dpResultX, const Ifl_DPResultF32_Type* dpResultY, const Ifl_DPResultF32_Type* dpResultZ, uint16 num_x, uint16 num_y, const sint16* Val_array) ⌋