Nexteer Library

• 1: Filter_Library_Design_Document
• 2: Interpolation_Design_MDD
• 3: NxtrLib_Systemtime Integration_Manual
• 4: Interpolation_UnitTestResults

1 - Filter_Library_Design_Document

1 Partial Notch Filter 3

1.1 Filter Equations 3

1.1.1 Node b State Variable Initialization 3

1.1.2 Node d State Variable Initialization 3

1.1.3 Filter Output Calculation 3

1.1.4 Node b State Variable Calculation 3

1.1.5 Node d State Variable Calculation 3

1.1.6 Filter Output Calculation 4

1.2 Library Routines Design 4

1.2.1 Notch Filter Initialization Function 4

1.2.2 Notch Filter State Variable Update Function 4

1.2.3 Notch Filter Output Update Function 4

1.2.4 Notch Filter Full Update Function 5

1.3 Notch Filter Structure Acceptable Ranges 5

1.4 Usage 6

2 1^st Order Low Pass Filter, 1 Pole- coefficient 7

2.1 Topology 1 – 1LP1-C 7

2.1.1 Filter Equations 8

2.1.2 Library Routines Design 8

2.1.2.1 Unity Gain, No Dead band Compensation, Fixed K – calibratable Kn, fixed 16 bit Kd, 32 Bit State Variable, Truncate divide, Unsigned 16 bit Input 8

2.1.2.2 Unity Gain, No Dead band Compensation, Fixed K – calibratable Kn, fixed 16 bit Kd, 32 Bit State Variable, Truncate divide, Signed 16 bit Input 11

2.2 Topology 2 – 1LP1-B 14

2.2.1 Filter Equations 14

2.2.2 Library Routines Design 15

2.2.2.1 Variable Gain, Variable D, Variable K – calibratable 16 bit Kn, variable Kd, 32 Bit State Variable, Truncate divide, Unsigned 16 bit Input 15

2.2.2.2 Variable Gain, Variable D, Variable K - calibratable 16 bit Kn, variable Kd, 32 Bit State Variable, Truncate divide, Signed 16 bit Input 17

2.3 Topology 3 – 1LP1-CF (Floating Point Implementation) 20

2.3.1 Filter Equations 20

2.3.1.1 Coefficient K Calculation and State Variable Initialization 20

2.3.1.2 Coefficient K Recalculation 20

2.3.1.3 Normal Operation 20

2.3.2 Library Routines Design 21

2.3.2.1 Unity Gain, No Dead band Compensation, calibratable K, Single-Precision Float Input 21

3 1^st Order High Pass Filter, 1 Pole- coefficient 23

3.1 Topology 1 – HP-CF (Floating Point Implementation) 23

3.1.1 Filter Equations 23

3.1.1.1 Coefficient K Calculation and State Variable Initialization 23

3.1.1.2 Coefficient K Recalculation 23

3.1.1.3 Normal Operation 23

3.1.2 Library Routines Design 24

3.1.2.1 Unity Gain, No Dead band Compensation, calibratable K, Single-Precision Float Input 24

4 Revision Control Log 26

Partial Notch Filter

Filter Equations

The first three equations, 1.1.1, 1.1.2, and 1.1.3 shall be combined into a single Notch Filter Initialization function. The next two equations 1.1.4 and 1.1.5 shall be combined into a single state variable update function. Finally, equation 1.1.6 shall be standalone as the output update function. For convenience, the last two function, state variable update and output update shall be combined into a single inline function to provide a single call from the modules _per() sub-module.

Node b State Variable Initialization

SV2 = In * (B2 - A2);

Node d State Variable Initialization

SV1 = In * (B1 + B2 - A1 - A2);

Filter Output Calculation

Out = In;

Node b State Variable Calculation

SV2 = (B2 * In) - (Out * A2);

Node d State Variable Calculation

SV1 = (SV2 + (In * B1)) - (Out * A1);

Filter Output Calculation

Out = SV1 + (B0 * In);

Library Routines Design

Notch Filter Initialization Function

Pseudo Code:

KPtr_Cnt_Str = FiltK_Cnt_T_Str;

Out = In;

SV1 = In * (B1 + B2 - A1 - A2);

SV2 = In * (B2 - A2);

Notch Filter State Variable Update Function

Pseudo Code: KPtr_Cnt_Str = FiltK_Cnt_T_Str

SV1 = (SV2 + (In * B1)) - (Out * A1);

SV2 = (B2 * In) - (Out * A2);

Notch Filter Output Update Function

Pseudo Code:

Out = SV1 + (B0 * In);

Notch Filter Full Update Function

Pseudo Code:

Full Update simply calls OpUpdate followed by SvUpdate as a convenient alternative to calling each of the functions individually.

Notch Filter Structure Acceptable Ranges

Usage

For a module that executes a Notch Filter, in its _Init() sub module execute the following function.

NF_Init_f32(<Input>, <SV_Ptr>, <FiltK_Ptr>);

In the same module’s _Per() sub module execute the following functions in the given sequence,

NF_OpUpdate_f32(<Input>, <SV_Ptr>);

NF_SvUpdate_f32(<Input>, <SV_Ptr>, <FiltK_Ptr>);

Alternatively, a single call to the following function can be made in place of the above pair within the _Per() sub module.

NF_FullUpdate_f32(<Input>, <SV_Ptr>, <FiltK_Ptr>);

1^st Order Low Pass Filter, 1 Pole- coefficient

Topology 1 – 1LP1-C

The Filter topology 1LP1-C is as given,

There may be multiple library functions defined for the same topology, based on the cut-off frequency, and input size requirements.

A filter tool is available to design the low pass filter for this topology – “1^st Order Design,1LP1-B.xls”. This tool provides the bit sizes for all nodes shown in the filter. The tool must be used to see which library function is required for the given input, cut-off frequency, sampling rate, and filter coefficient size.

The above filter topology requires the following constants to be defined

Filter Equations

The filter equations are given below. Each equation shall be implemented as a library macro.

State Variable (Node e) Initialization

The equation to initialize the state variable, (Node e) is as follows:

filt_SV = Input * Kd.

Output (Node O) Initialization

The equation to initialize the output, (Node O) is as follows:

filt_O = [( ( Input – (filt_SV / Kd) ) * Kn ) + filt_SV] / Kd

Normal Operation

During normal operation the state variable (Node e) shall be updated prior to the output of the filter (Node O) being updated.

The equation for the state variable (Node e) is as follows:

filt_SV = ( ( Input – (filt_SV / Kd) ) * Kn ) + filt_SV

The equation for the output (Node O) is as follows:

filt_O = filt_SV / Kd

The equations to update filt_Sv and filt_O or the library routines that calculate these values should be executed in the exact order shown above.

Library Routines Design

Unity Gain, No Dead band Compensation, Fixed K – calibratable Kn, fixed 16 bit Kd, 32 Bit State Variable, Truncate divide, Unsigned 16 bit Input

There will be four macros defined for this implementation:- state variable initialization, filter output initialization, state variable update and filter output update.

State Variable Initialization Macro

Pseudo Code:

Lvalue = Input << Kd

where Kd is pre-defined for a fixed16 bit filter coefficient = 16 bits

Filter Output Initialization Macro

Pseudo Code:

Lvalue = (((Input – (Filt_SV >> Kd)) * Kn ), + Filt_SV)>>Kd

where Kd is pre-defined for a fixed16 bit filter coefficient = 16 bits

Filter State Variable Update Macro

Pseudo code:

<Lvalue> = ( ( Input – (filt_SV >> Kd) ) * Kn ) + filt_SV

where Kd is pre-defined for a fixed16 bit filter coefficient = 16 bits

Output Update Macro

Pseudo code:

<Lvalue> = filt_SV >> Kd

where Kd is pre-defined for a 16 bit filter coefficient = 16 bits

Usage

For a module that executes a LPF, in its _Init() sub module execute the following macros in the given sequence

LPF_SvInit_u16InFixKTrunc_m (<Input>)

LPF_OpInit_u16InFixKTrunc_m (<Input>, <Filt_SV>, <Kn>)

In the same module’s _Per() sub module execute the following macros in the given sequence,

LPF_SvUpdate_u16InFixKTrunc_m (<Input>, <filt_SV>, <Kn>)

LPF_OpUpdate_u16InFixKTrunc_m ( <filt_SV>)

Unity Gain, No Dead band Compensation, Fixed K – calibratable Kn, fixed 16 bit Kd, 32 Bit State Variable, Truncate divide, Signed 16 bit Input

There will be three macros defined for this implementation:- state variable initialization, state variable update and filter output update.

State Variable Initialization Macro

Pseudo Code:

Lvalue = Input << Kd

where Kd is pre-defined for a 16 bit filter coefficient as 16 bits

Filter Output Initialization Macro

Pseudo Code:

Lvalue = (((Input – (Filt_SV >> Kd)) * Kn ), + Filt_SV)>>Kd

where Kd is pre-defined for a fixed16 bit filter coefficient = 16 bits

Filter State Variable Update Macro

Pseudo code:

<Lvalue> = ( ( Input – (filt_SV >> Kd) ) * Kn ) + filt_SV

where Kd is pre-defined for a 16 bit filter coefficient = 16 bits

Output Update Macro

Pseudo code:

<Lvalue> = filt_O >> Kd

where Kd is pre-defined for a 16 bit filter coefficient = 16

Usage

For a module that executes a LPF, in its _Init() sub module execute the following macros in the given sequence

LPF_SvInit_s16InFixKTrunc_m (<Input>)

LPF_OpInit_s16InFixKTrunc_m (<Input>, <Filt_SV>, <Kn>)

In the same module’s _Per() sub module execute the following macros in the given sequence

LPF_SvUpdate_s16InFixKTrunc_m (<Input>, <filt_SV>, <Kn>)

LPF_OpUpdate_s16InFixKTrunc_m ( <filt_SV>)

Topology 2 – 1LP1-B

The filter topology 1LP1-B is as given,

Filter Equations

The filter equations are given below. Each equation shall be implemented as a library macro.

State Variable (Node e) Initialization

The equation to initialize the state variable, (Node e) is as follows:

filt_SV = Input * G * Kd * D

Output (Node O) Initialization

The equation to initialize the output, (Node O) is as follows:

filt_O = [( ( (Input * G * D) – (filt_SV / Kd) ) * Kn ) + filt_SV] / (Kd * D)

Normal Operation

During normal operation the state variable (Node e) shall be updated prior to the output of the filter (Node O) being updated.

The equation for the state variable (Node e) is as follows:

filt_SV = ( ( (Input * G * D) – (filt_SV / Kd) ) * Kn ) + filt_SV

The equation for the output (Node O) is as follows:

filt_O = filt_SV / (Kd * D)

The equations to update filt_Sv and filt_O or the library routines that calculate these values should be executed in the exact order shown above.

The multiplication for the Filter Input by G shall be implemented external to the library macros. Thus the Input as used by the macros shall represent actual filter input * G, for non unity gain filter implementation.

Note: Constraint on this filter is that Node b cannot exceed 16 bits.

Library Routines Design

Variable Gain, Variable D, Variable K – calibratable 16 bit Kn, variable Kd, 32 Bit State Variable, Truncate divide, Unsigned 16 bit Input

State Variable Initialization Macro

Pseudo Code:

Lvalue = (Input << Kd) << D

Note:- The multiplication by D shall not be performed for D = 0.

Filter Output Initialization Macro

Pseudo Code:

Lvalue = [((((Input<<D) – (Filt_SV >> Kd)) * Kn ) + Filt_SV)>>Kd]>>D

Note:- The multiplication and division by D shall not be performed for D = 0.

Filter State Variable Update Macro

Pseudo code:

<Lvalue> = ( ( (Input << D) – (filt_SV >> Kd) ) * Kn ) + filt_SV

Note:- The multiplication by D shall not be performed for D = 0.

Output Update Macro

Pseudo code:

<Lvalue> = (filt_SV >> Kd ) >>D

Note:- The division by D shall not be performed for D = 0.

Usage

For a module that executes a LPF, in its _Init() sub module execute the following macros in the given sequence

LPF_SvInit_u16InVarKTrunc_m (<Input>, <Kd>, <D>)

LPF_OpInit_u16InVarKTrunc_m (<Input>, <Filt_SV>, <Kn>, <Kd>, <D>)

In the same module’s _Per() sub module execute the following macros in the given sequence,

LPF_SvUpdate_u16InVarKTrunc_m (<Input>, <filt_SV>, <Kn>, <Kd>, <D>)

LPF_OpUpdate_u16InVarKTrunc_m ( <filt_SV>, <Kd>, <D>)

Variable Gain, Variable D, Variable K - calibratable 16 bit Kn, variable Kd, 32 Bit State Variable, Truncate divide, Signed 16 bit Input

State Variable Initialization Macro

Pseudo Code:

Lvalue = (Input << Kd) << D

Note:- The multiplication by D shall not be performed for D = 0.

Filter Output Initialization Macro

Pseudo Code:

Lvalue = [((((Input<<D) – (Filt_SV >> Kd)) * Kn ), + Filt_SV)>>Kd]>>D

Note:- The multiplication and division by D shall not be performed for D = 0.

Filter State Variable Update Macro

Pseudo code:

<Lvalue> = ( ( (Input << D) – (filt_SV >> Kd) ) * Kn ) + filt_SV

Note:- The multiplication by D shall not be performed for D = 0.

Output Update Macro

Pseudo code:

<Lvalue> = (filt_SV >> Kd ) >>D

Note:- The division by D shall not be performed for D = 0.

Usage

For a module that executes a LPF, in its _Init() sub module execute the following macros in the given sequence

LPF_SvInit_s16InVarKTrunc_m (<Input>, <Kd>, <D>)

LPF_OpInit_s16InVarKTrunc_m (<Input>, <Filt_SV>, <Kn>, <Kd>, <D>)

In the same module’s _Per() sub module execute the following macros in the given sequence,

LPF_SvUpdate_s16InVarKTrunc_m (<Input>, <filt_SV>, <Kn>, <Kd>, <D>)

LPF_OpUpdate_s16InVarKTrunc_m ( <filt_SV>, <Kd>, <D>)

Topology 3 – 1LP1-CF (Floating Point Implementation)

The filter topology 1LP1-CF is as given,

Filter Equations

The filter equations are given below. Each equation shall be implemented as a library macro.

Coefficient K Calculation and State Variable Initialization

The equation to calculate the filter coefficient K is as follows: (Where Fp is in hertz and T is in seconds.)

K = 1 – exp(-2 * π * Fp * T)

And the equation for initialization of the state variable is as follows:

Filt_SV = Input

Coefficient K Recalculation

The equation for recalculation of the filter coefficient K is exactly the same as that defined in the initialization function above.

Normal Operation

The equation for the output (Node O) is as follows:

filt_Out = ( ( Input – prev_SV ) * K ) + prev_SV

The value of filt_SV is the value of filt_Out from the previous call to the above function.

Library Routines Design

Unity Gain, No Dead band Compensation, calibratable K, Single-Precision Float Input

There will be three macros defined for this implementation:- state variable and coefficient initialization, coefficient calculation, and filter output update.

Coefficient and State Variable Initialization Macro

Pseudo Code:

<SV_Str-> SV_Uls_f32> = Input

<Lvalue> = Input

LPF_KUpdate_f32_m(Fp, T, SV_Str)

Coefficient Recalculation Macro

Pseudo Code:

<SV_Str-> K_Uls_f32> = 1 – expf(-2π * Fp * T)

Output Update Macro

Pseudo code:

<Lvalue> = <SV_Str->SV_Uls_f32> =

(Input – <SV_Str->SV_Uls_f32>) * <SV_Str->K_Uls_f32> + <SV_Str->SV_Uls_f32>

Usable ranges for LPF32KSV_Str Structure

Usage

For a module that executes a LPF, in its _Init() sub module execute the following macros:

LPF_Init_f32_m(<Input>, <Fp>, <T>, <LPF32KSV_Str>)

In the same module’s _Per() sub module execute the following macro:

LPF_OpUpdate_f32_m ( <Input>, <LPF32KSV_Str>)

The module may optionally call the following macro if the coefficient value K needs to be updated on the fly to support variable cutoff filtering.

LPF_KUpdate_f32_m(<Fp>, <T>, <LPF32KSV_Str>)

1^st Order High Pass Filter, 1 Pole- coefficient

Topology 1 – HP-CF (Floating Point Implementation)

The filter topology HP-CF is as given:

Filter Equations

The filter equations are given below. Each equation shall be implemented as a library macro.

Low Pass Filter

The low-pass filter aspect of the design uses the 1LP1-CF implementation as described in section 2.3.

CF Calculation

The CF (correction factor) is calculated as follows:

CF = (1 + exp(2PI * Fp * T)) / (2 * sqrt(1 + ((2 * Fp * T)^2)))

Normal Operation

The equation for the output is as follows:

filt_Out = ( Input – LPF_Output ) * CF

Library Routine Design

Unity Gain, No Dead band Compensation, calibratable K, Single-Precision Float Input

There will be three macros defined for this implementation: state variable and coefficient initialization, coefficient calculation, and filter output update. The interface for these macros will be similar to that of the 1LP1-CF low pass filter design.

Coefficient and State Variable Initialization Macro

Pseudo Code:

LPF_Init_f32_m(Input, Fp, T, &(SV_Ptr->LPF_Str))

HPF_KUpdate_f32_m(Fp, T, SV_Ptr)

Coefficient Recalculation Macro

Pseudo Code:

SV_Ptr->CF = (1 + exp(2PI * Fp * T)) / (2 * sqrt(1 + ((2 * Fp * T)^2)))

LPF_KUpdate_f32_m(Fp_f32, T_f32, &(SV_Ptr->LPF_Str))

Output Update Macro

Pseudo code:

(Input - LPF_OpUpdate_f32_m(input_f32, &(SV_Ptr->LPF_Str))) * SV_Ptr->CF_Uls_f32

Usable ranges for HPF32KSV_Str Structure

Usage

For a module that executes a HPF, in its _Init() sub module execute the following macros:

HPF_Init_f32_m(<Input>, <Fp>, <T>, <HPF32KSV_Str>)

In the same module’s _Per() sub module execute the following macro:

HPF_OpUpdate_f32_m ( <Input>, <HPF32KSV_Str>)

The module may optionally call the following macro if the coefficient value K needs to be updated on the fly to support variable cutoff filtering:

HPF_KUpdate_f32_m(<Fp>, <T>, <HPF32KSV_Str>)

Revision Control Log

2 - Interpolation_Design_MDD

1 Variable X Variable Y 2D Table Lookup function (with interpolation) 2

1.1 Requirement 2

1.2 Implementation: 2

1.2.1 Unsigned X, Unsigned Y 4

1.2.2 Signed X, Unsigned Y 5

1.2.3 Signed X, Signed Y 7

1.2.4 Unsigned X, Signed Y 8

2 Fixed X Variable Y 2D Table Lookup function (with interpolation) 11

2.1 Requirement 11

2.2 Implementation: 11

2.2.1 Unsigned X, Unsigned Y 11

2.2.2 Signed X, Unsigned Y 13

2.2.3 Signed X, Signed Y 14

2.2.4 Unsigned X, Signed Y 16

3 Single X Multiple Y (Bilinear Interpolation) 17

3.1 Implementation: 17

3.1.1 Syntax: BilinearXYM_s16_u16Xs16YM_Cnt (BS, input, *BSTbl, BSize, *XTbl, *YMTbl, Xsize) 17

3.1.2 Syntax: BilinearXYM_u16_u16Xu16YM_Cnt(BS, input, *BSTbl, BSsize, *XTbl, *YMTbl, Xsize) 20

3.1.3 Syntax: BilinearXYM_s16_s16Xs16YM_Cnt (BS, input, *BSTbl, BSize, *XTbl, *YMTbl, Xsize) 23

3.1.4 Syntax: BilinearXYM_u16_s16Xu16YM_Cnt(BS, input, *BSTbl, BSsize, *XTbl, *YMTbl, Xsize) 26

4 Multiple X Multiple Y (Bilinear Interpolation) 29

4.1 Implementation 29

4.1.1 Syntax: BilinearXMYM_u16_u16XMu16YM_Cnt( BS, input, *BSTbl, BSsize, *XMTbl, *YMTbl, Xsize) 29

4.1.2 Syntax: BilinearXMYM_s16_u16XMs16YM_Cnt(BS, input, *BSTbl, BSsize, *XMTbl, *YMTbl, Xsize) 32

4.1.3 Syntax: BilinearXMYM_u16_s16XMu16YM_Cnt( BS, input, *BSTbl, BSsize, *XMTbl, *YMTbl, Xsize) 40

5 UnitTesting Range: Linear and Bilinear Interpolation 44

6 Revision Control Log 44

Variable X Variable Y 2D Table Lookup function (with interpolation)

Requirement

The Variable X Variable Y 2D table has the Variable X as the input (independent variable) and the Variable Y as the output (dependent variable). The lookup function with interpolation is used to interpolate the values of Y corresponding to the input value for X. This is implemented using the straight-line equation as given below:

$$y = (\frac{y_{n + 1} - y_{n}}{x_{n + 1} - x_{n}}) \ast (x - x_{n}) + y_{n}$$

where,

n = index into the independent and dependent variable tables

n+1 = next consecutive index into the tables.

(y_n+1 - y_n) = interval in the dependent table within which the interpolated output is calculated.

(x_n+1 - x_n) = interval in the independent table within which the input lies.

y = interpolated output (dependent variable)

x = input (independent variable)

Note that y_n+1 < y_n or y_n+1 > y_n, for negative or positive slopes and x_n+1 > x_n.

The index n and n+1, are determined using Straight-Forward Search method. Using the indices, the values of x_n+1, x_n, y_n+1 and y_n are determined.

The difference (y_n+1 - y_n) is held in a signed variable to ensure that the interpolation can handle both positive and negative slopes.

The Variable X VariableY interpolation function is defined as a function with the input x value and table name passed as parameters. The function will return the interpolated output y as its output.

Implementation:

Note: Straight Forward Search method is used for calculating the index n.

Unsigned X, Unsigned Y

Syntax : IntplVarXY_u16_u16Xu16Y_Cnt ( *TableX, *TableY, Size, input)

Arguments:

1) TableX: - The Variable X 2D table (independent table)

2) TableY: - The Variable Y 2D table (dependent table)

3) Size: - Size of the table

4) input: - The input to the table

output: The output from the table.

Pseudo Code :

UINT16 input, output, Size

UINT16 index = 0

SINT16 diffY, diffX, diffXinput, tmpout2

SINT32 tmpout1

const UINT16 TableX = [ x1, x2, x3, x4, x5,….. ]

const UINT16 TableY = [ y1, y2, y3, y4, y5,….. ]

/* Check for Range */

if ( input <= TableX[0] )

return TableY[0]

else if ( input >= TableX[size-1] )

return TableY[size-1]

endif

/* In range. Get Index */

while ( TableX[index + 1] < input )

index = index + 1

endwhile

/* Interpolate and get the output */

diffY = TableY[index+1] - TableY[index]

diffX = TableX[index+1] - TableX[index]

diffXinput = input - TableX[index]

/* Product in 32 bit */

tmpout1 = diffY* diffXinput

/* Check if Divide by zero */

if (diffX == 0)

tmpout2 = 0

else

/* Here, the lower 16 bits are assigned to tmpout2 */

tmpout2 = tmpout1 / diffX

endif

output = tmpout2 + TableY[index]

return output

end

Signed X, Unsigned Y

Syntax : IntplVarXY_u16_s16Xu16Y_Cnt (*TableX, *TableY, Size, input)

Arguments:

1) TableX: - The Variable X 2D table (independent table)

2) TableY: - The Variable Y 2D table (dependent table)

3) Size: - Size of the table

4) input: - The input to the table

output: The output from the table.

Pseudo Code :

SINT16 input

UINT16 output, Size

UINT16 index = 0

SINT16 diffY, diffX, diffXinput, tmpout2

SINT32 tmpout1

const SINT16 TableX = [ x1, x2, x3, x4, x5,….. ]

const UINT16 TableY = [ y1, y2, y3, y4, y5,….. ]

/* Check for Range */

if ( input <= TableX[0] )

return TableY[0]

else if ( input >= TableX[size-1] )

return TableY[size-1]

endif

/* In range. Get Index */

while ( TableX[index + 1] < input )

index = index + 1

endwhile

/* Interpolate and get the output */

diffY = TableY[index+1] - TableY[index]

diffX = TableX[index+1] - TableX[index]

diffXinput = input - TableX[index]

/* Product in 32 bit */

tmpout1 = diffY * diffXinput

/* Check if Divide by zero */

if (diffX == 0)

tmpout2 = 0

else

/* Here, the lower 16 bits are assigned to tmpout2 */

tmpout2 = tmpout1 / diffX

endif

output = tmpout2 + TableY[index]

return output

end

Signed X, Signed Y

Syntax : IntplVarXY_s16_s16Xs16Y_Cnt (*TableX, *TableY, Size, input)

Arguments:

1) TableX: - The Variable X 2D table (independent table)

2) TableY: - The Variable Y 2D table (dependent table)

3) Size: - Size of the table

4) input: - The input to the table

output: The output from the table.

Pseudo Code :

SINT16 input, output

UINT16 Size

UINT16 index = 0

SINT16 diffY, diffX, diffXinput, tmpout2

SINT32 tmpout1

const SINT16 TableX = [ x1, x2, x3, x4, x5,….. ]

const SINT16 TableY = [ y1, y2, y3, y4, y5,….. ]

/* Check for Range */

if ( input <= TableX[0] )

return TableY[0]

else if ( input >= TableX[size-1] )

return TableY[size-1]

endif

/* In range. Get Index */

while ( TableX[index + 1] < input )

index = index + 1

endwhile

/* Interpolate and get the output */

diffY = TableY[index+1] - TableY[index]

diffX = TableX[index+1] - TableX[index]

diffXinput = input - TableX[index]

/* Product in 32 bit */

tmpout1 = diffY * diffXinput

/* Check if Divide by zero */

if (diffX == 0)

tmpout2 = 0

else

/* Here, the lower 16 bits are assigned to tmpout2 */

tmpout2 = tmpout1 / diffX

endif

output = tmpout2 + TableY[index]

return output

end

Unsigned X, Signed Y

Syntax : IntplVarXY_s16_u16Xs16Y_Cnt (*TableX, *TableY, Size, input)

Arguments:

1) TableX: - The Variable X 2D table (independent table)

2) TableY: - The Variable Y 2D table (dependent table)

3) Size: - Size of the table

4) input: - The input to the table

output: The output from the table.

Pseudo Code :

UINT16 input, Size

SINT16 output

UINT16 index = 0

SINT16 diffY, diffX, diffXinput, tmpout2

SINT32 tmpout1

const UINT16 TableX = [ x1, x2, x3, x4, x5,….. ]

const SINT16 TableY = [ y1, y2, y3, y4, y5,….. ]

/* Check for Range */

if ( input <= TableX[0] )

return TableY[0]

else if ( input >= TableX[size-1] )

return TableY[size-1]

endif

/* In range. Get Index */

while ( TableX[index + 1] < input )

index = index + 1

endwhile

/* Interpolate and get the output */

diffY = TableY[index+1] - TableY[index]

diffX = TableX[index+1] - TableX[index]

diffXinput = input - TableX[index]

/* Product in 32 bit */

tmpout1 = diffY * diffXinput

/* Check if Divide by zero */

if (diffX == 0)

tmpout2 = 0

else

/* Here, the lower 16 bits are assigned to tmpout2 */

tmpout2 = tmpout1 / diffX

endif

output = tmpout2 + TableY[index]

return output

end

Fixed X Variable Y 2D Table Lookup function (with interpolation)

Requirement

The Fixed X Variable Y 2D table has the Fixed X as the input (independent variable) and the Variable Y (dependent variable) as the output. The interpolation function is used to interpolate the values of Y corresponding to the input value for X. It is assumed that the independent axis (X) will always start from 0. This is implemented using the straight-line equation as given below:

$$y = (\frac{y_{n + 1} - y_{n}}{\Delta x}) \ast (x - x_{n}) + y_{n}$$

where,

n = index into the Table

(y_n+1 - y_n) = interval in the dependent table within which the interpolated output is calculated.

∆x = fixed X interval within which the input lies.

y = interpolated output

x = input

Determine the value of n, i.e the index into the table, n = truncate ( x / ∆x ). Using this index n, determine the values of x_n, y_n and y_n+1. The output y can then be calculated based on the straight line given above.

Implementation:

Unsigned X, Unsigned Y

Syntax : IntplFxdX_u16_u16Xu16Y_Cnt (DeltaX, *TableY, Size, input)

Arguments:

1. DeltaX: - The Fixed X interval

2. TableY: - The Variable Y 2D table (dependent table)

3. Size: - Size of the table

4. input: - The input to the table

output: The output from the table.

Pseudo Code :

UINT16 input, output, Size

UINT16 index = 0

SINT16 diffY, diffXinput, tmpout2

SINT32 tmpout1

const UINT16 TableY = [ y1, y2, y3, y4, y5,….. ]

if (DeltaX == 0)

/* Cannot do interpolation. Return Y0 */

return TableY[0]

endif

/* Check for Range */

if ( input <= 0 )

return TableY[0]

else if ( input >= DeltaX * (size-1) )

return TableY[size-1]

endif

/* In range. Get Index */

index = truncate (input / DeltaX)

/* Interpolate and get the output */

diffY = TableY[index+1] - TableY[index]

diffXinput = input - DeltaX * index

/* Product in 32 bit */

tmpout1 = diffY * diffXinput

/* Here, the lower 16 bits are assigned to tmpout2 */

tmpout2 = tmpout1 / DeltaX

output = tmpout2 + TableY[index]

return output

end

Signed X, Unsigned Y

Syntax : IntplFxdX_u16_s16Xu16Y_Cnt (DeltaX, *TableY, Size, input)

Arguments:

1. DeltaX: - The Fixed X interval

2. TableY: - The Variable Y 2D table (dependent table)

3. Size: - Size of the table

4. input: - The input to the table

output: The output from the table.

Pseudo Code :

SINT16 input

UINT16 output, Size

UINT16 index = 0

SINT16 diffY, diffXinput, tmpout2

SINT32 tmpout1

const UINT16 TableY = [ y1, y2, y3, y4, y5,….. ]

if (DeltaX == 0)

/* Cannot do interpolation. Return Y0 */

return TableY[0]

endif

/* Check for Range */

if ( input <= 0 )

return TableY[0]

else if ( input >= DeltaX * (size-1) )

return TableY[size-1]

endif

/* In range. Get Index */

index = truncate (input / DeltaX)

/* Interpolate and get the output */

diffY = TableY[index+1] - TableY[index]

diffXinput = input - DeltaX * index

/* Product in 32 bit */

tmpout1 = diffY * diffXinput

/* Here, the lower 16 bits are assigned to tmpout2 */

tmpout2 = tmpout1 / DeltaX

output = tmpout2 + TableY[index]

return output

end

Signed X, Signed Y

Syntax: IntplFxdX_s16_s16Xs16Y_Cnt (DeltaX, *TableY, Size, input)

Arguments:

1. DeltaX: - The Fixed X interval

2. TableY: - The Variable Y 2D table (dependent table)

3. Size: - Size of the table

4. input: - The input to the table

output: The output from the table.

Pseudo Code :

SINT16 input, output

UINT16 Size

UINT16 index = 0

SINT16 diffY, diffXinput, tmpout2

SINT32 tmpout1

const SINT16 TableY = [ y1, y2, y3, y4, y5,….. ]

if (DeltaX == 0)

/* Cannot do interpolation. Return Y0 */

return TableY[0]

endif

/* Check for Range */

if ( input <= 0 )

return TableY[0]

else if ( input >= DeltaX * (size-1) )

return TableY[size-1]

endif

/* In range. Get Index */

index = truncate (input / DeltaX)

/* Interpolate and get the output */

diffY = TableY[index+1] - TableY[index]

diffXinput = input - DeltaX * index

/* Product in 32 bit */

tmpout1 = diffY * diffXinput

/* Here, the lower 16 bits are assigned to tmpout2 */

tmpout2 = tmpout1 / DeltaX

output = tmpout2 + TableY[index]

return output

end

Unsigned X, Signed Y

Syntax: IntplFxdX_s16_u16Xs16Y_Cnt (DeltaX, *TableY, Size, input)

Arguments:

1. DeltaX: - The Fixed X interval

2. TableY: - The Variable Y 2D table (dependent table)

3. Size: - Size of the table

4. input: - The input to the table

output: The output from the table.

Pseudo Code :

UINT16 input, Size

SINT16 output

UINT16 index = 0

SINT16 diffY, diffXinput, tmpout2

SINT32 tmpout1

const SINT16 TableY = [ y1, y2, y3, y4, y5,….. ]

if (DeltaX == 0)

/* Cannot do interpolation. Return Y0 */

return TableY[0]

endif

/* Check for Range */

if ( input <= 0 )

return TableY[0]

else if ( input >= DeltaX * (size-1) )

return TableY[size-1]

endif

/* In range. Get Index */

index = truncate (input / DeltaX)

/* Interpolate and get the output */

diffY = TableY[index+1] - TableY[index]

diffXinput = input - DeltaX * index

/* Product in 32 bit */

tmpout1 = diffY * diffXinput

/* Here, the lower 16 bits are assigned to tmpout2 */

tmpout2 = tmpout1 / DeltaX

output = tmpout2 + TableY[index]

return output

end

Single X Multiple Y (Bilinear Interpolation)

Implementation:

Syntax: BilinearXYM_s16_u16Xs16YM_Cnt (BS, input, *BSTbl, BSize, *XTbl, *YMTbl, Xsize)

Arguments:

1. BS:- Bilinear Selector

2. Input:-The input to the table

3. BSTbl:- Bilinear Selector Table 2D

4. BSize:- Bilinear Selector Table Size

5. XTbl:- Table X 2D

6. YMTbl:- Table Y with MxN dimension

7. Xsize:- Size of XTbl

Output:- The output from the table

Pseudo Code:

UINT16 BSindex, Xindex

UINT16 ArrayIndex1, ArrayIndex2, ArrayIndex3, ArrayIndex4

SINT32 BSinputDiff, XInputDiff

FLOAT32 Numerator_f32, Denominator_f32, Output_f32

SINT16 Output_s16

Const UINT16 BSTbl = [z1,z2,z3,z4,…..]

Const UINT16 XTbl = [x1,x2,x3,x4,…...]

Const SINT16 YMTbl[mxn] = [(y1,y2,y3…),(y4,y5,y6….),….]

If (BS <= BSTbl[0])

BSindex = 0

BS = BSTbl[0]

Else if (BS >= BSTbl[BSize-1])

BSindex = BSsize -2

BS = BSTbl[BSsize -1]

While ((BSTbl[BSindex] = = BSTbl[BSindex + 1] && (BSindex > 0)))

BSindex = BSindex - 1

Wend

Else

BSindex = 0

While ( BSTbl[BSindex +1] < BS)

BSindex = BSindex + 1

Wend

Endif

If (input <= XTbl[0])

Xindex = 0

Input = XTbl[0]

Else if (input >= XTbl[XSize – 1])

Xindex = Xsize – 2

Input = XTbl[Xsize -1]

Else

Xindex = 0

While ( XTbl[Xindex +1] < input)

Xindex = Xindex+1

Wend

Endif

ArrayIndex1 = (BSindex * Xsize) + Xindex

ArrayIndex2 = (BSindex * Xsize) + Xindex + 1

ArrayIndex3 = ((BSindex + 1) * Xsize) + Xindex

ArrayIndex4 = ((BSindex + 1) * Xsize) + Xindex + 1

BSInputDiff = BS – BSTbl[BSindex]

XInputDiff = input – XTbl[Xindex]

Numerator_f32 = ( YMTbl[ArrayIndex2] – YMTbl[ArrayIndex1]) * ((BSTbl[BSindex+1] – BSTbl[BSindex]) * XInputDiff) +

(YMTbl[ArrayIndex3] – YMTbl[ArrayIndex1]) *

(BSInputDiff * (XTbl[Xindex+1] – XTbl[Xindex])) +

(XInputDiff * BSInputDiff ) *

((YMTbl[ArrayIndex4]) – (YMTbl[ArrayIndex3]) – (YMTbl[ArrayIndex2] – YMTbl[ArrayIndex1]))

Denominator_f32 = (BSTbl[BSindex +1] – BSTbl[BSindex]) * (XTbl[Xindex+1] – XTbl[Xindex])

If (Denominator_f32 <= FLT_EPSILON)

Output_f32 = YMTbl[ArrayIndex1]

Else

Output_f32 = YMTbl[ArrayIndex1] + Numerator_f32 / Denominator_f32

Endif

If (Output_f32 >= 0)

Output_f32 = Output_f32 + 0.5

Else

Output_f32 =Output_f32 – 0.5

Endif

/*Float to SINT16 typecast*/

Output_s16 = Output_f32

return Output_s16

End

Syntax: BilinearXYM_u16_u16Xu16YM_Cnt(BS, input, *BSTbl, BSsize, *XTbl, *YMTbl, Xsize)

Arguments

1. BS:- Bilinear Selector

2. input:-The input to the table

3. BSTbl:- Bilinear Selector Table 2D

4. BSize:- Bilinear Selector Table Size

5. XTbl:- Table X 2D

6. YMTbl:- Table Y with MxN dimension

7. Xsize:- Size of XTbl

Output:- The output from the table

Pseudo Code:

UINT16 BSindex, Xindex

UINT16 ArrayIndex1, ArrayIndex2, ArrayIndex3, ArrayIndex4

SINT32 BSInputDiff, XInputDiff

FLOAT32 Numerator_f32, Denominator_f32

UINT16 Output_u16

Const UINT16 BSTbl = [z1,z2,z3,z4,…..]

Const UINT16 XTbl = [x1,x2,x3,x4,…...]

Const UINT16 YMTbl[mxn] = [(y1,y2,y3…),(y4,y5,y6….),….]

If (BS <= BSTbl[0])

BSindex = 0

BS = BSTbl[0]

Else if (BS >= BSTbl[BSsize – 1])

BSindex = BSsize -2

BS = BSTbl [ BSsize – 1]

While (( BSTbl [BSindex] == BSTbl [ BSindex+1] && (BSindex > 0)))

BSindex = BSindex – 1

Wend

Else

BSindex = 0

While (BSTbl[BSindex +1]<BS)

BSindex = BSindex +1

Wend

Endif

If (input <= XTbl[0])

Xindex = 0

Input = XTbl[0]

Else if (input >= XTbl[XSize -1])

Xindex = Xsize -2

input = XTbl[Xsize -1]

Else

Xindex = 0

While ( XTbl[Xindex + 1] < input)

Xindex= Xindex + 1

Wend

Endif

ArrayIndex1 = (BSindex * Xsize) + Xindex

ArrayIndex2 = (BSindex * Xsize) + Xindex + 1

ArrayIndex3 = ((BSindex + 1)* Xsize) + Xindex

ArrayIndex4 = ((BSindex + 1)* Xsize) + Xindex + 1

BSInputDiff = BS – BSTbl[BSindex]

XInputDiff = input – XTbl[Xindex]

Numerator_f32 = ( YMTbl[ArrayIndex2] – YMTbl[ArrayIndex1]) *

((BSTbl [ BSindex + 1] – BSTbl[BSindex]) * XInputDiff) +

(YMTbl [ ArrayIndex3] – YMTbl[ArrayIndex1]) *

(BSInputDiff * (XTbl[Xindex+1] – XTbl[Xindex])) +

(XInputDiff * BSInputDiff) *

((YMTbl[ArrayIndex4]) – (YMTbl[ArrayIndex3]) – (YMTbl[ArrayIndex2] – YMTbl[ArrayIndex1]))

Denominator_f32 = (BSTbl[BSindex+1] – BSTbl[BSindex]) * (XTbl[Xindex+1] – XTbl[Xindex])

If (Denominator_f32 <= FLT_EPSILON) Output_u16 = YMTbl[ArrayIndex1] + 0.5

Else

Output_u16 = YMTbl[ArrayIndex1] + (Numerator_f32 / Denominator_f32) + 0.5

Endif

return Output_u16

end

Syntax: BilinearXYM_s16_s16Xs16YM_Cnt (BS, input, *BSTbl, BSize, *XTbl, *YMTbl, Xsize)

Arguments:

1. BS:- Bilinear Selector

2. Input:-The input to the table

3. BSTbl:- Bilinear Selector Table 2D

4. BSize:- Bilinear Selector Table Size

5. XTbl:- Table X 2D

6. YMTbl:- Table Y with MxN dimension

7. Xsize:- Size of XTbl

Output:- The output from the table

Pseudo Code:

UINT16 BSindex, Xindex

UINT16 ArrayIndex1, ArrayIndex2, ArrayIndex3, ArrayIndex4

SINT32 BSinputDiff, XInputDiff

FLOAT32 Numerator_f32, Denominator_f32, Output_f32

SINT16 Output_s16

Const UINT16 BSTbl = [z1,z2,z3,z4,…..]

Const UINT16 XTbl = [x1,x2,x3,x4,…...]

Const SINT16 YMTbl[mxn] = [(y1,y2,y3…),(y4,y5,y6….),….]

If (BS <= BSTbl[0])

BSindex = 0

BS = BSTbl[0]

Else if (BS >= BSTbl[BSize-1])

BSindex = BSsize -2

BS = BSTbl[BSsize -1]

While ((BSTbl[BSindex] = = BSTbl[BSindex + 1] && (BSindex > 0)))

BSindex = BSindex - 1

Wend

Else

BSindex = 0

While ( BSTbl[BSindex +1] < BS)

BSindex = BSindex + 1

Wend

Endif

If (input <= XTbl[0])

Xindex = 0

Input = XTbl[0]

Else if (input >= XTbl[XSize – 1])

Xindex = Xsize – 2

Input = XTbl[Xsize -1]

Else

Xindex = 0

While ( XTbl[Xindex +1] < input)

Xindex = Xindex+1

Wend

Endif

ArrayIndex1 = (BSindex * Xsize) + Xindex

ArrayIndex2 = (BSindex * Xsize) + Xindex + 1

ArrayIndex3 = ((BSindex + 1) * Xsize) + Xindex

ArrayIndex4 = ((BSindex + 1) * Xsize) + Xindex + 1

BSInputDiff = BS – BSTbl[BSindex]

XInputDiff = input – XTbl[Xindex]

Numerator_f32 = ( YMTbl[ArrayIndex2] – YMTbl[ArrayIndex1]) * ((BSTbl[BSindex+1] – BSTbl[BSindex]) * XInputDiff) +

(YMTbl[ArrayIndex3] – YMTbl[ArrayIndex1]) *

(BSInputDiff * (XTbl[Xindex+1] – XTbl[Xindex])) +

(XInputDiff * BSInputDiff ) *

((YMTbl[ArrayIndex4]) – (YMTbl[ArrayIndex3]) – (YMTbl[ArrayIndex2] – YMTbl[ArrayIndex1]))

Denominator_f32 = (BSTbl[BSindex +1] – BSTbl[BSindex]) * (XTbl[Xindex+1] – XTbl[Xindex])

If (Denominator_f32 <= FLT_EPSILON) Output_f32 = YMTbl[ArrayIndex1]

Else

Output_f32 = YMTbl[ArrayIndex1] + Numerator_f32 / Denominator_f32

Endif

If (Output_f32 >= 0)

Output_f32 = Output_f32 + 0.5

Else

Output_f32 =Output_f32 – 0.5

Endif

/*Float to SINT16 typecast*/

Output_s16 = Output_f32

return Output_s16

End

Syntax: BilinearXYM_u16_s16Xu16YM_Cnt(BS, input, *BSTbl, BSsize, *XTbl, *YMTbl, Xsize)

Arguments

1. BS:- Bilinear Selector

2. input:-The input to the table

3. BSTbl:- Bilinear Selector Table 2D

4. BSize:- Bilinear Selector Table Size

5. XTbl:- Table X 2D

6. YMTbl:- Table Y with MxN dimension

7. Xsize:- Size of XTbl

Output:- The output from the table

Pseudo Code:

UINT16 BSindex, Xindex

UINT16 ArrayIndex1, ArrayIndex2, ArrayIndex3, ArrayIndex4

SINT32 BSInputDiff, XInputDiff

FLOAT32 Numerator_f32, Denominator_f32

UINT16 Output_u16

Const UINT16 BSTbl = [z1,z2,z3,z4,…..]

Const UINT16 XTbl = [x1,x2,x3,x4,…...]

Const UINT16 YMTbl[mxn] = [(y1,y2,y3…),(y4,y5,y6….),….]

If (BS <= BSTbl[0])

BSindex = 0

BS = BSTbl[0]

Else if (BS >= BSTbl[BSsize – 1])

BSindex = BSsize -2

BS = BSTbl [ BSsize – 1]

While (( BSTbl [BSindex] == BSTbl [ BSindex+1] && (BSindex > 0)))

BSindex = BSindex – 1

Wend

Else

BSindex = 0

While (BSTbl[BSindex +1]<BS)

BSindex = BSindex +1

Wend

Endif

If (input <= XTbl[0])

Xindex = 0

Input = XTbl[0]

Else if (input >= XTbl[XSize -1])

Xindex = Xsize -2

input = XTbl[Xsize -1]

Else

Xindex = 0

While ( XTbl[Xindex + 1] < input)

Xindex= Xindex + 1

Wend

Endif

ArrayIndex1 = (BSindex * Xsize) + Xindex

ArrayIndex2 = (BSindex * Xsize) + Xindex + 1

ArrayIndex3 = ((BSindex + 1)* Xsize) + Xindex

ArrayIndex4 = ((BSindex + 1)* Xsize) + Xindex + 1

BSInputDiff = BS – BSTbl[BSindex]

XInputDiff = input – XTbl[Xindex]

Numerator_f32 = ( YMTbl[ArrayIndex2] – YMTbl[ArrayIndex1]) *

((BSTbl [ BSindex + 1] – BSTbl[BSindex]) * XInputDiff) +

(YMTbl [ ArrayIndex3] – YMTbl[ArrayIndex1]) *

(BSInputDiff * (XTbl[Xindex+1] – XTbl[Xindex])) +

(XInputDiff * BSInputDiff) *

((YMTbl[ArrayIndex4]) – (YMTbl[ArrayIndex3]) – (YMTbl[ArrayIndex2] – YMTbl[ArrayIndex1]))

Denominator_f32 = (BSTbl[BSindex+1] – BSTbl[BSindex]) * (XTbl[Xindex+1] – XTbl[Xindex])

If (Denominator_f32 <= FLT_EPSILON) Output_u16 = YMTbl[ArrayIndex1] + 0.5

Else

Output_u16 = YMTbl[ArrayIndex1] + (Numerator_f32 / Denominator_f32) + 0.5

Endif

return Output_u16

end

Multiple X Multiple Y (Bilinear Interpolation)

Implementation

Syntax: BilinearXMYM_u16_u16XMu16YM_Cnt( BS, input, *BSTbl, BSsize, *XMTbl, *YMTbl, Xsize)

Arguments:

1. BS:- Bilinear Selector

2. input:-The input to the table

3. BSTbl:- Bilinear Selector Table 2D

4. BSize:- Bilinear Selector Table Size

5. XTbl:- Table X with [MxN] dimension

6. YMTbl:- Table Y with [MxN] dimension

7. Xsize:- Size of XTbl

Output:- The output from the table

Pseudo Code:

UINT16 BSindex, X1index, X2index,

UINT16 ArrayIndex1, ArrayIndex2, ArrayIndex3, ArrayIndex4

SINT32 BSInputDiff, XInputDiff1, XInputDiff2

SINT32 Mult1_s32, Mult2_s32

FLOAT32 Numerator_f32, Denominator_f32

UINT16 Output_u16

SINT32 Den1_s32, Den2_s32, Den3_s32

UINT16 input2 = input

Const UINT16 BSTbl = [z1,z2,z3,z4,…..]

Const UINT16 XTbl[mxn] = [(x1,x2,x3…),(x4,x5,x6….),….]

Const UINT16 YMTbl[mxn] = [(y1,y2,y3…),(y4,y5,y6….),….]

If ( BS <= BSTbl[0] )

BSindex = 0

BS = BSTbl [0]

Else if (BS >= BSTbl[BSsize -1])

BSindex = BSsize – 2

BS = BSTbl [ BSsize-1]

while (BSTbl[BSindex] == BSTbl[BSindex+1] && (BSindex > 0))

BSindex = BSindex -1

wend

Else

BSindex = 0

while ( BSTbl [ BSindex +1] < BS)

BSindex = BSindex +1

wend

Endif

If ( input <= XMTbl [ BSindex * Xsize])

X1index = 0

Input = XMTbl [BSindex * Xsize]

Else if (input >= XMTbl [ (BSindex * Xsize) + Xsize -1])

X1index = Xsize – 2

input = XMTbl [ (BSindex * Xsize) + Xsize – 1]

while ((XMTbl[(BSindex * Xsize)+X1index] == XMTbl[(BSindex * Xsize) + X1index +1]) && (X1index >0))

X1index = X1index – 1

wend

Else

X1index = 0

while (XMTbl[(BSindex * Xsize)+X1index+1] <input)

X1index = X1index + 1

wend

Endif

If (input2 <= XMTb1 [(BSindex+1) * Xsize])

X2index = 0

input2 = XMTbl[(BSindex + 1) * Xsize ]

Else if (input2 >= XMTbl [ ((BSindex +1) * Xsize) + Xsize -1])

X2index = Xsize -2

input2 = XMTbl[((BSindex +1)*Xsize) + Xsize -1]

while ((XMTbl[((BSindex+1)*Xsize)+X2index]==XMTbl[((BSindex+1)*Xsize)+X2index+1]) && (X2index >0))

X2index = X2index – 1

wend

Else

X2index = 0

while ( XMTbl[((BSindex+1)*Xsize)+X2index+1]<input)

X2index = X2index +1

wend

Endif

ArrayIndex1 = (BSindex * Xsize) + X1index

ArrayIndex2 = (BSindex * Xsize) + X1index + 1

ArrayIndex3 = ((BSindex +1)* Xsize) + X2index

ArrayIndex4 = ((BSindex +1)*Xsize)+X2index+1

XInputDiff1 = input – XMTbl[ArrayIndex1]

XInputDiff2 = input2 – XMTbl[ArrayIndex3]

BSInputDiff = BS – BSTbl[BSindex]

Mult1_s32 = XInputDiff1 * (XMTbl[ArrayIndex4] – XMTbl[ArrayIndex3])

Mult2_s32 = BSInputDiff * (XMTbl[ArrayIndex2] – XMTbl[ArrayIndex1])

Den1_s32 = (XMTbl[ArrayIndex4]-XMTbl[ArrayIndex3])

Den2_s32 = (XMTbl[ArrayIndex2] – XMTbl[ArrayIndex1])

Den3_s32 = (BSTbl[BSindex +1]-BSTbl[BSindex])

Numerator_f32 = Mult1_s32 * (BSTbl[BSindex+1]-BS) *

(YMTbl[ArrayIndex2]-YMTbl[ArrayIndex1]) +

Mult2_s32*(XMTbl[ArrayIndex4] – XMTbl[ArrayIndex3]) *

(YMTbl[ArrayIndex3] – YMTbl[ArrayIndex1]) +

Mult2_s32 * XInputDiff2*(YMTbl[ArrayIndex4] – YMTbl[ArrayIndex3])

Denominator_f32 = (Den1_s32 * Den2_s32) * Den3_s32

If (Denominator_f32 <= FLT_EPSILON)

Output_u16 = YMTbl[ArrayIndex1] + 0.5

Else

Output_u16 = YMTbl[ArrayIndex1] + (Numerator_f32 / Denominator_f32) + 0.5

Endif

return Output_u16

end

Syntax: BilinearXMYM_s16_u16XMs16YM_Cnt(BS, input, *BSTbl, BSsize, *XMTbl, *YMTbl, Xsize)

Arguments:

1. BS:- Bilinear Selector

2. input:-The input to the table

3. BSTbl:- Bilinear Selector Table 2D

4. BSize:- Bilinear Selector Table Size

5. XTbl:- Table X with [MxN] dimension

6. YMTbl:- Table Y with [MxN] dimension

7. Xsize:- Size of XTbl

Output:- The output from the table

Pseudo Code:

UINT16 BSindex, X1index, X2index

UINT16 ArrayIndex1, ArrayIndex2, ArrayIndex3, ArrayIndex4

SINT32 BSInputDiff, XInputDiff1, XInputDiff2

SINT32 Mult1_s32, Mult2_s32

FLOAT32 Numerator_f32, Denominator_f32

SINT16 Output_s16

SINT32 Den1_s32, Den2_s32, Den3_s32

UINT16 input2 = input

FLOAT32 Output_f32

Const UINT16 BSTbl = [z1,z2,z3,z4,…..]

Const UINT16 XTbl[mxn] = [(x1,x2,x3…),(x4,x5,x6….),….]

Const SINT16 YMTbl[mxn] = [(y1,y2,y3…),(y4,y5,y6….),….]

If ( BS <= BSTbl[0])

BSindex = 0

BS = BSTbl[0]

Else if (BS >= BSTbl[BSsize -1])

BSindex = BSsize – 2

BS = BSTbl [ BSsize – 1]

While ( BSTbl[BSindex] == BSTbl[BSindex + 1] && (BSindex >0))

BSindex = BSindex – 1

Wend

Else

BSindex = 0

While (BSTbl[BSindex +1] < BS)

BSindex = BSindex +1

Wend

Endif

If (input <= XMTbl[BSindex * Xsize ] )

X1index =0

input = XMTbl[BSindex * Xsize]

else if (input >= XMTbl[(BSindex * Xsize) + Xsize -1])

X1index = Xsize -2

input = XMTbl[(BSindex * Xsize) + Xsize -1]

while (( XMTbl[(BSindex * Xsize) + X1index] == XMTbl[(BSindex * Xsize) +X1index+1]) && (X1index > 0))

X1index =X1index – 1

Wend

Else

X1index = 0

While (XMTbl[(BSindex * Xsize)+X1index+1] < input)

X1index = X1index +1

Wend

Endif

If (input2 <= XMTbl[(BSindex+1) * Xsize])

X2index =0

Input2 = XMTbl[(BSindex+1)* Xsize]

Else if (input2 >= XMTbl[(BSindex+1) * Xsize) + XSize-1])

X2index = Xsize – 2

input2 = XMTbl[((BSindex +1)*Xsize)+Xsize – 1]

while ((XMTbl[((BSindex+1)*Xsize)+X2index] == XMTbl[((BSindex+1) * Xsize)+X2index+1]) && (X2index >0))

X2index = X2index – 1

Wend

Else

X2index =0

While (XMTbl[((Bsindex+1)* Xsize) + X2index +1] < input)

X2index= X2index+1

Wend

Endif

ArrayIndex1 = (BSindex * Xsize) + X1index

ArrayIndex2 = (BSindex * Xsize) + X1index + 1

ArrayIndex3 = ((BSindex+1)*Xsize)+X2index

ArrayIndex4 = ((BSindex + 1)*Xsize) + X2index+1

XInputDiff1 = input – XMTbl[ArrayIndex1]

XInputDiff2 = input2 – XMTbl[ArrayIndex3]

BSInputDiff = BS – BSTbl[BSindex]

Mult1_s32 = XInputDiff1 * (XMTbl[ArrayIndex4] – XMTbl[ArrayIndex3])

Mult2_s32 = BSinputDiff * (XMTbl[ArrayIndex2] – XMTbl[ArrayIndex1])

Den1_s32 = (XMTbl[ArrayIndex4] - XMTbl[ArrayIndex3])

Den2_s32 = (XMTbl[ArrayIndex2] – XMTbl[ArrayIndex1])

Den3_s32 = (BSTbl[BSindex+1] – BSTbl[BSindex])

Numerator_f32 = Mult1_s32 * ((BSTbl[BSindex+1]-BS) * (YMTbl[ArrayIndex2] – YMTbl[ArrayIndex1]) +

Mult2_s32 * (XMTbl[ArrayIndex4]-XMTbl[ArrayIndex3])*

YMTbl[ArrayIndex3] – YMTbl[ArrayIndex1]) +

Mult2_s32*XInputDiff2*(YMTbl[ArrayIndex4]-YMTbl[ArrayIndex3])

Denominator_f32 = (Den1_s32 * Den2_s32) * Den3_s32

If (Denominator_f32 <= FLT_EPSILON)

Output_f32 = YMTbl[ArrayIndex1]

Else

Output_f32 = YMTbl[ArrayIndex1]+Numerator_f32/Denominator_f32

Endif

If (Output_f32 >= 0)

Output_f32 = Output_f32 +0.5

Else

Output_f32 = Output_f32 -0.5

Endif

/*float to SINT16 typecasting*/

Output_s16 = Output_f32

return Output_s16

end

4.1.3 Syntax: BilinearXMYM_s16_s16XMs16YM_Cnt(BS, input, *BSTbl, BSsize, *XMTbl, *YMTbl, Xsize)

Arguments:

1. BS:- Bilinear Selector

2. input:-The input to the table

3. BSTbl:- Bilinear Selector Table 2D

4. BSize:- Bilinear Selector Table Size

5. XTbl:- Table X with [MxN] dimension

6. YMTbl:- Table Y with [MxN] dimension

7. Xsize:- Size of XTbl

Output:- The output from the table

Pseudo Code:

UINT16 BSindex, X1index, X2index

UINT16 ArrayIndex1, ArrayIndex2, ArrayIndex3, ArrayIndex4

SINT32 BSInputDiff, XInputDiff1, XInputDiff2

SINT32 Mult1_s32, Mult2_s32

FLOAT32 Numerator_f32, Denominator_f32

SINT16 Output_s16

SINT32 Den1_s32, Den2_s32, Den3_s32

SINT16 input2 = input

FLOAT32 Output_f32

Const UINT16 BSTbl = [z1,z2,z3,z4,…..]

Const SINT16 XTbl[mxn] = [(x1,x2,x3…),(x4,x5,x6….),….]

Const SINT16 YMTbl[mxn] = [(y1,y2,y3…),(y4,y5,y6….),….]

If (BS <= BSTbl[0])

BSindex = 0

BS = BSTbl[0]

Else if (BS >= BSTbl[BSsize-1]

BSindex = BSsize – 2

BS = BSTbl[BSsize – 1]

While ( BSTbl[BSindex] == BSTbl[BSindex+1] && (BSindex >0))

BSindex = BSindex -1

Wend

Else

BSindex = 0

While (BSTbl[BSindex+1] < BS)

BSindex = BSindex +1

Wend

Endif

If (input <= XMTbl[BSindex * Xsize])

X1index = 0

input = XMTbl[BSindex * Xsize]

else if (input >= XMTbl[(BSindex * Xsize) + Xsize – 1])

X1index = Xsize-2

input = XMTbl[(BSindex*Xsize)+Xsize-1]

while ((XMTbl[(BSindex*Xsize)+X1index] = = XMTbl[(BSindex * Xsize)+X1index+1]) && (X1index > 0))

X1index = X1index-1

Wend

Else

X1index = 0

While ( XMTbl[(BSindex * Xsize) + X1index+1] < input)

X1index = X1index+1

Wend

Endif

If (input2 <= XMTbl[(BSindex+1)*Xsize])

X2index = 0

input2= XMTbl[(BSindex+1)*Xsize]

else if (input2 >= XMTbl[((BSindex+1)*Xsize)+Xsize-1])

X2index = Xsize-2

input2 = XMTbl[((BSindex+1)*Xsize)+Xsize-1]

while (( XMTbl[(BSindex+1)*Xsize) + X2index] == XMTbl[((BSindex+1)*Xsize)+X2index+1]) && (X2index > 0))

X2index = X2index-1

Wend

Else

X2index = 0

While ( XMTbl[((BSindex+1)*Xsize)+X2index+1] < input)

X2index = X2index+1

Wend

Endif

ArrayIndex1 = (BSindex * Xsize) + X1index

ArrayIndex2 = (BSindex * Xsize) + X1index + 1

ArrayIndex3 = ((BSindex +1)*Xsize)+X2index

ArrayIndex4 = ((BSindex + 1)*Xsize)+X2index+1

XInputDiff1 = input – XMTbl[ArrayIndex1]

XInputDiff2 = inpu2 – XMTbl[ArrayIndex3]

BSInputDiff = BS – BSTbl[BSindex]

Mult1_s32 = XInputDiff1 * (XMTbl[ArrayIndex4] – XMTbl[ArrayIndex3])

Mult2_s32 = BSInputDiff * (XMTbl[ArrayIndex2] – XMTbl[ArrayIndex1])

Den1_s32 = (XMTbl[ArrayIndex4] – XMTbl[ArrayIndex3])

Den2_s32 = (XMTbl[ArrayIndex2] – XMTbl[ArrayIndex1])

Den3_s32 = (BSTbl[BSindex + 1] – BSTbl[BSindex])

Numerator_f32 = Mult1_s32 * ((BSTbl[BSindex+1]-BS)* (YMTbl[ArrayIndex2]-YMTbl[ArrayIndex1])+

Mult2_s32 * (XMTbl[ArrayIndex4]-XMTbl[ArrayIndex3]) *

(YMTbl[ArrayIndex3] – YMTbl[ArrayIndex1]) +

Mult2_s32 * XInputDiff2 * (YMTbl[ArrayIndex4] – YMTbl[ArrayIndex3])

Denominator_f32 = (Den1_s32 * Den2_s32) * Den3_s32

If (Denominator_f32 <= FLT_EPSILON)

Output_f32 = YMTbl[ArrayIndex1]

Else

Output_f32 = YMTbl[ArrayIndex1] + Numerator_f32 / Denominator_f32

Endif

If (Output_f32 >= 0)

Output_f32 = Output_f32 +0.5

Else

Output_f32 = Output_f32 – 0.5

Endif

/*float to SINT16 typecast*/

Output_s16 = Output_f32

return Output_s16

end

Syntax: BilinearXMYM_u16_s16XMu16YM_Cnt( BS, input, *BSTbl, BSsize, *XMTbl, *YMTbl, Xsize)

Arguments:

1. BS:- Bilinear Selector

2. input:-The input to the table

3. BSTbl:- Bilinear Selector Table 2D

4. BSize:- Bilinear Selector Table Size

5. XTbl:- Table X with [MxN] dimension

6. YMTbl:- Table Y with [MxN] dimension

7. Xsize:- Size of XTbl

Output:- The output from the table

Pseudo Code:

UINT16 BSindex, X1index, X2index,

UINT16 ArrayIndex1, ArrayIndex2, ArrayIndex3, ArrayIndex4

SINT32 BSInputDiff, XInputDiff1, XInputDiff2

SINT32 Mult1_s32, Mult2_s32

FLOAT32 Numerator_f32, Denominator_f32

UINT16 Output_u16

SINT32 Den1_s32, Den2_s32, Den3_s32

UINT16 input2 = input

Const UINT16 BSTbl = [z1,z2,z3,z4,…..]

Const UINT16 XTbl[mxn] = [(x1,x2,x3…),(x4,x5,x6….),….]

Const UINT16 YMTbl[mxn] = [(y1,y2,y3…),(y4,y5,y6….),….]

If ( BS <= BSTbl[0] )

BSindex = 0

BS = BSTbl [0]

Else if (BS >= BSTbl[BSsize -1])

BSindex = BSsize – 2

BS = BSTbl [ BSsize-1]

while (BSTbl[BSindex] == BSTbl[BSindex+1] && (BSindex > 0))

BSindex = BSindex -1

wend

Else

BSindex = 0

while ( BSTbl [ BSindex +1] < BS)

BSindex = BSindex +1

wend

Endif

If ( input <= XMTbl [ BSindex * Xsize])

X1index = 0

Input = XMTbl [BSindex * Xsize]

Else if (input >= XMTbl [ (BSindex * Xsize) + Xsize -1])

X1index = Xsize – 2

input = XMTbl [ (BSindex * Xsize) + Xsize – 1]

while ((XMTbl[(BSindex * Xsize)+X1index] == XMTbl[(BSindex * Xsize) + X1index +1]) && (X1index >0))

X1index = X1index – 1

wend

Else

X1index = 0

while (XMTbl[(BSindex * Xsize)+X1index+1] <input)

X1index = X1index + 1

wend

Endif

If (input2 <= XMTb1 [(BSindex+1) * Xsize])

X2index = 0

input2 = XMTbl[(BSindex + 1) * Xsize ]

Else if (input2 >= XMTbl [ ((BSindex +1) * Xsize) + Xsize -1])

X2index = Xsize -2

input2 = XMTbl[((BSindex +1)*Xsize) + Xsize -1]

while ((XMTbl[((BSindex+1)*Xsize)+X2index]==XMTbl[((BSindex+1)*Xsize)+X2index+1]) && (X2index >0))

X2index = X2index – 1

wend

Else

X2index = 0

while ( XMTbl[((BSindex+1)*Xsize)+X2index+1]<input)

X2index = X2index +1

wend

Endif

ArrayIndex1 = (BSindex * Xsize) + X1index

ArrayIndex2 = (BSindex * Xsize) + X1index + 1

ArrayIndex3 = ((BSindex +1)* Xsize) + X2index

ArrayIndex4 = ((BSindex +1)*Xsize)+X2index+1

XInputDiff1 = input – XMTbl[ArrayIndex1]

XInputDiff2 = input2 – XMTbl[ArrayIndex3]

BSInputDiff = BS – BSTbl[BSindex]

Mult1_s32 = XInputDiff1 * (XMTbl[ArrayIndex4] – XMTbl[ArrayIndex3])

Mult2_s32 = BSInputDiff * (XMTbl[ArrayIndex2] – XMTbl[ArrayIndex1])

Den1_s32 = (XMTbl[ArrayIndex4]-XMTbl[ArrayIndex3])

Den2_s32 = (XMTbl[ArrayIndex2] – XMTbl[ArrayIndex1])

Den3_s32 = (BSTbl[BSindex +1]-BSTbl[BSindex])

Numerator_f32 = Mult1_s32 * (BSTbl[BSindex+1]-BS) *

(YMTbl[ArrayIndex2]-YMTbl[ArrayIndex1]) +

Mult2_s32*(XMTbl[ArrayIndex4] – XMTbl[ArrayIndex3]) *

(YMTbl[ArrayIndex3] – YMTbl[ArrayIndex1]) +

Mult2_s32 * XInputDiff2*(YMTbl[ArrayIndex4] – YMTbl[ArrayIndex3])

Denominator_f32 = (Den1_s32 * Den2_s32) * Den3_s32

If (Denominator_f32 <= FLT_EPSILON)

Output_u16 = YMTbl[ArrayIndex1] + 0.5

Else

Output_u16 = YMTbl[ArrayIndex1] + (Numerator_f32 / Denominator_f32) + 0.5

Endif

return Output_u16

end

UnitTesting Range: Linear and Bilinear Interpolation

For unit testing consider Ranges as FULL based on the data type of the tables and Input. Note a limitation for all interpolation functions is that the X tables and the BS Tables are assumed to be always increasing in value (or equal). The tables should never be decreasing in values as the index increases.

Revision Control Log

3 - NxtrLib_Systemtime Integration_Manual

Contents

1 Dependencies 1

2 Configuration 1

2.1 Build Time Config 1

2.2 Generator Config 1

2.2.1 System 1

2.2.2 NvMProxyBlock 2

3 Integration 2

4 Runnable Scheduling 2

5 Memory Mapping 3

5.1 Mapping 3

5.2 Usage 3

6 Revision Control Log 4

Dependencies

Configuration

Build Time Config

Generator Config

System

Integration

The following import steps must be completed:

1. Place CBD project structure to appropriate integration folder

2. Copy SystemTime_Cfg.h.tt into the Header folder and remove the .tt extension.

3. Configure the constant D_TickRate_Cnt_u32 to the appropriate Os system tick time.

Runnable Scheduling

This section specifies the required runnable scheduling.

Memory Mapping

Mapping

* Each …START_SEC… constant is terminated by a …STOP_SEC… constant as specified in the AUTOSAR Memory Mapping requirements.

Usage

Revision Control Log

4 - Interpolation_UnitTestResults

Nexteer EPS Unit Test Tool
Rev:2.7b
Module Definitions
Module Test Functions				Module Set/Read Variables					Module Function Stubs
Return Type	Name	Parameter Prototype		Scope	Type	Name	Default Value		Return Type	Name	Parameter Prototype
sint16	BilinearXYM_s16_u16Xs16YM_Cnt	(uint16 BS1, uint16 input1, uint16 BSsize1, uint16 Xsize1)		G	uint16	BilinearXYM_s16_u16Xs16YM_Cnt_BSTbl[3]
uint16	BilinearXYM_u16_u16Xu16YM_Cnt	(uint16 BS2, uint16 input2, uint16 BSsize2, uint16 Xsize2)		G	uint16	BilinearXYM_s16_u16Xs16YM_Cnt_XTbl[3]
uint16	BilinearXMYM_u16_u16XMu16YM_Cnt	(uint16 BS3, uint16 input3, uint16 BSsize3, uint16 Xsize3)		G	sint16	BilinearXYM_s16_u16Xs16YM_Cnt_YMTbl1[3]
sint16	BilinearXMYM_s16_u16XMs16YM_Cnt	(uint16 BS4, uint16 input4, uint16 BSsize4, uint16 Xsize4)		G	sint16	BilinearXYM_s16_u16Xs16YM_Cnt_YMTbl2[3]
sint16	BilinearXMYM_s16_s16XMs16YM_Cnt	(uint16 BS5, sint16 input5, uint16 BSsize5, uint16 Xsize5)		G	sint16	BilinearXYM_s16_u16Xs16YM_Cnt_YMTbl3[3]
uint16	IntplVarXY_u16_u16Xu16Y_Cnt	(uint16 Size6, uint16 input6)		G	uint16	BilinearXYM_u16_u16Xu16YM_Cnt_BSTbl[3]
uint16	IntplVarXY_u16_s16Xu16Y_Cnt	(uint16 Size7, sint16 input7)		G	uint16	BilinearXYM_u16_u16Xu16YM_Cnt_XTbl[3]
sint16	IntplVarXY_s16_s16Xs16Y_Cnt	(uint16 Size8, sint16 input8)		G	uint16	BilinearXYM_u16_u16Xu16YM_Cnt_YMTbl1[3]
sint16	IntplVarXY_s16_u16Xs16Y_Cnt	(uint16 Size9, uint16 input9)		G	uint16	BilinearXYM_u16_u16Xu16YM_Cnt_YMTbl2[3]
uint16	IntplFxdX_u16_u16Xu16Y_Cnt	(uint16 DeltaX10, uint16 Size10, uint16 input10)		G	uint16	BilinearXYM_u16_u16Xu16YM_Cnt_YMTbl3[3]
uint16	IntplFxdX_u16_s16Xu16Y_Cnt	(sint16 DeltaX11, uint16 Size11, sint16 input11)		G	uint16	BilinearXMYM_u16_u16XMu16YM_Cnt_BSTbl[3]
sint16	IntplFxdX_s16_s16Xs16Y_Cnt	(sint16 DeltaX12, uint16 Size12, sint16 input12)		G	uint16	BilinearXMYM_u16_u16XMu16YM_Cnt_XMTbl1[3]
sint16	IntplFxdX_s16_u16Xs16Y_Cnt	(uint16 DeltaX13, uint16 Size13, uint16 input13)		G	uint16	BilinearXMYM_u16_u16XMu16YM_Cnt_XMTbl2[3]
				G	uint16	BilinearXMYM_u16_u16XMu16YM_Cnt_XMTbl3[3]
				G	uint16	BilinearXMYM_u16_u16XMu16YM_Cnt_YMTbl1[3]
				G	uint16	BilinearXMYM_u16_u16XMu16YM_Cnt_YMTbl2[3]
				G	uint16	BilinearXMYM_u16_u16XMu16YM_Cnt_YMTbl3[3]
				G	uint16	BilinearXMYM_s16_u16XMs16YM_Cnt_BSTbl[3]
				G	uint16	BilinearXMYM_s16_u16XMs16YM_Cnt_XMTbl1[3]
				G	uint16	BilinearXMYM_s16_u16XMs16YM_Cnt_XMTbl2[3]
				G	uint16	BilinearXMYM_s16_u16XMs16YM_Cnt_XMTbl3[3]
				G	sint16	BilinearXMYM_s16_u16XMs16YM_Cnt_YMTbl1[3]
				G	sint16	BilinearXMYM_s16_u16XMs16YM_Cnt_YMTbl2[3]
				G	sint16	BilinearXMYM_s16_u16XMs16YM_Cnt_YMTbl3[3]
				G	uint16	BilinearXMYM_s16_s16XMs16YM_Cnt_BSTbl[3]
				G	sint16	BilinearXMYM_s16_s16XMs16YM_Cnt_XMTbl1[3]
				G	sint16	BilinearXMYM_s16_s16XMs16YM_Cnt_XMTbl2[3]
				G	sint16	BilinearXMYM_s16_s16XMs16YM_Cnt_XMTbl3[3]
				G	sint16	BilinearXMYM_s16_s16XMs16YM_Cnt_YMTbl1[3]
				G	sint16	BilinearXMYM_s16_s16XMs16YM_Cnt_YMTbl2[3]
				G	sint16	BilinearXMYM_s16_s16XMs16YM_Cnt_YMTbl3[3]
				G	uint16	IntplVarXY_u16_u16Xu16Y_Cnt_TableX[4]
				G	uint16	IntplVarXY_u16_u16Xu16Y_Cnt_TableY[4]
				G	sint16	IntplVarXY_u16_s16Xu16Y_Cnt_TableX[3]
				G	uint16	IntplVarXY_u16_s16Xu16Y_Cnt_TableY[3]
				G	sint16	IntplVarXY_s16_s16Xs16Y_Cnt_TableX[3]
				G	sint16	IntplVarXY_s16_s16Xs16Y_Cnt_TableY[3]
				G	uint16	IntplVarXY_s16_u16Xs16Y_Cnt_TableX[3]
				G	sint16	IntplVarXY_s16_u16Xs16Y_Cnt_TableY[3]
				G	uint16	IntplFxdX_u16_u16Xu16Y_Cnt_TableY[3]
				G	uint16	IntplFxdX_u16_s16Xu16Y_Cnt_TableY[3]
				G	sint16	IntplFxdX_s16_s16Xs16Y_Cnt_TableY[3]
				G	sint16	IntplFxdX_s16_u16Xs16Y_Cnt_TableY[3]

Nexteer EPS Unit Test Tool
Rev:2.7b
Variable Range Definitions
Variable Name	Max Value	Min Value
BilinearXYM_s16_u16Xs16YM_Cnt_BSTbl[3]
BilinearXYM_s16_u16Xs16YM_Cnt_XTbl[3]
BilinearXYM_s16_u16Xs16YM_Cnt_YMTbl1[3]
BilinearXYM_s16_u16Xs16YM_Cnt_YMTbl2[3]
BilinearXYM_s16_u16Xs16YM_Cnt_YMTbl3[3]
BilinearXYM_u16_u16Xu16YM_Cnt_BSTbl[3]
BilinearXYM_u16_u16Xu16YM_Cnt_XTbl[3]
BilinearXYM_u16_u16Xu16YM_Cnt_YMTbl1[3]
BilinearXYM_u16_u16Xu16YM_Cnt_YMTbl2[3]
BilinearXYM_u16_u16Xu16YM_Cnt_YMTbl3[3]
BilinearXMYM_u16_u16XMu16YM_Cnt_BSTbl[3]
BilinearXMYM_u16_u16XMu16YM_Cnt_XMTbl1[3]
BilinearXMYM_u16_u16XMu16YM_Cnt_XMTbl2[3]
BilinearXMYM_u16_u16XMu16YM_Cnt_XMTbl3[3]
BilinearXMYM_u16_u16XMu16YM_Cnt_YMTbl1[3]
BilinearXMYM_u16_u16XMu16YM_Cnt_YMTbl2[3]
BilinearXMYM_u16_u16XMu16YM_Cnt_YMTbl3[3]
BilinearXMYM_s16_u16XMs16YM_Cnt_BSTbl[3]
BilinearXMYM_s16_u16XMs16YM_Cnt_XMTbl1[3]
BilinearXMYM_s16_u16XMs16YM_Cnt_XMTbl2[3]
BilinearXMYM_s16_u16XMs16YM_Cnt_XMTbl3[3]
BilinearXMYM_s16_u16XMs16YM_Cnt_YMTbl1[3]
BilinearXMYM_s16_u16XMs16YM_Cnt_YMTbl2[3]
BilinearXMYM_s16_u16XMs16YM_Cnt_YMTbl3[3]
BilinearXMYM_s16_s16XMs16YM_Cnt_BSTbl[3]
BilinearXMYM_s16_s16XMs16YM_Cnt_XMTbl1[3]
BilinearXMYM_s16_s16XMs16YM_Cnt_XMTbl2[3]
BilinearXMYM_s16_s16XMs16YM_Cnt_XMTbl3[3]
BilinearXMYM_s16_s16XMs16YM_Cnt_YMTbl1[3]
BilinearXMYM_s16_s16XMs16YM_Cnt_YMTbl2[3]
BilinearXMYM_s16_s16XMs16YM_Cnt_YMTbl3[3]
IntplVarXY_u16_u16Xu16Y_Cnt_TableX[4]
IntplVarXY_u16_u16Xu16Y_Cnt_TableY[4]
IntplVarXY_u16_s16Xu16Y_Cnt_TableX[3]
IntplVarXY_u16_s16Xu16Y_Cnt_TableY[3]
IntplVarXY_s16_s16Xs16Y_Cnt_TableX[3]
IntplVarXY_s16_s16Xs16Y_Cnt_TableY[3]
IntplVarXY_s16_u16Xs16Y_Cnt_TableX[3]
IntplVarXY_s16_u16Xs16Y_Cnt_TableY[3]
IntplFxdX_u16_u16Xu16Y_Cnt_TableY[3]
IntplFxdX_u16_s16Xu16Y_Cnt_TableY[3]
IntplFxdX_s16_s16Xs16Y_Cnt_TableY[3]
IntplFxdX_s16_u16Xs16Y_Cnt_TableY[3]