This is the multi-page printable view of this section. Click here to print.
Libraries
1.1 - Data Dictionary
Overview
Change LogVariable Dictionary
Calibration Dictionary
Global Constants
Template
Help
Sheet 1: Change Log
| Metrics - Rev 2 | <- Global Program / Module Name | ||||||
| Revision | Author | Date | Change Description | Data Dictionary Type: | Component | ||
| 1 | JJW | 1-Feb-12 | Initial version | ||||
| 2 | BWL | 1-Jul-12 | Modified variables changed with PMU integration, and filled out existing information. | ||||
Sheet 2: Variable Dictionary
Sheet 3: Calibration Dictionary
Sheet 4: Global Constants
| Metrics - Rev 2 | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Variable Information (Global Variables Only) | Achieved in Software Design | Used in Module List | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Layer 2 | Layer 3 | Layer 4 | Layer 5 | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Constant Name | Description | Uints | Type | Engineering Value | ADC | ADC Diagnostics | Data Memory Verification | DC Link Power Control | DSP Computational Integrity | DSP SPI driver | Event Manager Driver | External Memory Driver | Flash Programming Exec | GPIO | Illegal OpCode Handler | Interrupt Handler | Motor Current Driver | Motor Driver Diagnostics | Motor Position Driver | Phase Feedback Capture | Powerdown Control | Primary Shutdown Control | Program Flow | Program Memory Diagnostic | PWM Duty Cycle | Redundant Memory Check | Redundant Rapid Shutdown | Scheduler | Stack Monitor | State Dependent Task List | System Boot & Startup | System Control | Temperature Sensor Diagnostic | Unused Interrupt Handler | Utilization Monitor | Watchdog Dirver | Smith | Battery Voltage | Battery Voltage Diagnostics | Diagnostic CTC Manager | Diagnostic Manager | Diagnostics Application Services | EOL TorqueTest | Flash Boot Loader | Flight Recorder | Handwheel Position | Handwheel Torque | Motor Control Output Conversion | Motor Position Diagnostics | Motor Position Initialization | Motor Velocity | Motor Velocity Tachometer | Serial Communications I/O | Serial Communications Services | States and Modes | Tuning Select | Vehicle Power Mode | Vehicle Speed | Controller Polarity | Current Estimation | Handwheel Velocity | Inverse Motor Model | Motor Temperature Estimation | Motor Torque Limit | Output Reasonableness Dianostic | Parameter Estimation | Quadrant and rate Detection | Active Pull Compensation | Assist | Damping | Duty Cycle | Kinematic Integrity Diagnostic | Long Term Vehicle Speed Diagnostic | Max Assist Limit | Return | State Output Control | Torque Output |
Sheet 5: Template
| 2.2a | Data File: | |||||
| Header: | extern <TYPE><TAB><NAME>; | |||||
| Source: | #pragma DATA_SECTION(<ROOTNAME>, "<SEGMENT>"); <TYPE> <NAME>; | |||||
| EOL Constants: | ||||||
| Header: | extern <TYPE><TAB><NAME>; | |||||
| Source: | #pragma DATA_SECTION(<ROOTNAME>, "<SEGMENT>"); <TYPE> <NAME>; | |||||
| Global (Embedded) Constants: | ||||||
| Header: | #define <NAME><COL40><VALUE> | |||||
| A2L Name | ||||||
| Measurement: | rte_<SWC>_<NAME> | |||||
| Calibration Constants: | ||||||
| Tuning ID: | ||||||
| Tuning: | N | Index Range: | ||||
| Header: | extern CONST(<AUTOSAR_TYPE>, CAL_CONST) <NAME>; | |||||
| Source: | #pragma DATA_SECTION(<ROOTNAME>, ".<SEGMENT>"); CONST(<AUTOSAR_TYPE>, CAL_CONST) <NAME> = <VALUE>; | |||||
| eCal: | <NAME> | |||||
| Tuning: | Y | Index Range: | ||||
| Header: | <NONCRITICAL> #define <ROOTNAME><TAB>k_N_CalNC_Cnt_Str.<ROOTNAME> <NONCRITICAL> <SAFETYCRITICAL> #define <ROOTNAME><TAB>k_S_CalSC_Cnt_Str.<ROOTNAME> <SAFETYCRITICAL> | |||||
| Source: | ||||||
| eCal: | <NONCRITICAL> k_N_CalNC_Cnt_Str.<ROOTNAME> <NONCRITICAL> <SAFETYCRITICAL> k_S_CalSC_Cnt_Str.<ROOTNAME> <SAFETYCRITICAL> | |||||
| Tuning: | P | Index Range: | ||||
| Header: | <NONCRITICAL> #define <ROOTNAME><TAB>k_N_CalNC_Cnt_Str.Personality[L3_S_CalPersSelect_Cnt_G_u16].<ROOTNAME> <NONCRITICAL> <SAFETYCRITICAL> #define <ROOTNAME><TAB>k_S_CalSC_Cnt_Str.SC_Personality[L3_S_CalPersSelect_Cnt_G_u16].<ROOTNAME> <SAFETYCRITICAL> | |||||
| Source: | ||||||
| eCal: | <NONCRITICAL> k_N_CalNC_Cnt_Str.Personality[L3_S_CalPersSelect_Cnt_G_u16].<ROOTNAME> <NONCRITICAL> <SAFETYCRITICAL> k_S_CalSC_Cnt_Str.SC_Personality[L3_S_CalPersSelect_Cnt_G_u16].<ROOTNAME> <SAFETYCRITICAL> | |||||
Sheet 6: Help
| Short cut | Macro | Sescription |
| Ctrl-q | ClearDataDictFilter | Will clear all autofilters on the Global Data Dictionary |
| DFD_Create | Creates a Series of Data Flow Worksheet Pages from the information in the data dictionary. If Data Flow Worksheet pages already exist, they will be deleted first. | |
| DFD_Delete | Will clear all Data Flow Diagram pages from the Data Dictionary. This will make the file smaller for archiving. | |
| DFD_Print | Formate and prepares to print the Data Flow Worksheet pages. |
1.2 - Metrics_Integration_Manual
Contents
Dependencies
| Module | Required Feature |
|---|---|
| Rte | Rte_Task_Dispatch() hooks VFB Trace hooks |
| Dio | Dio_WriteChannel() |
| Port | Port_SetPinDirection() |
| NxtrLib | DtrmnElapsedTime_uS_u32() GetSystemTime_uS_u32() |
| Os | osdNumberOfAllTasks constant value osGetStackUsage oskTcbStackTop oskTcbStackBottom |
Configuration
Build Time Config
| Constant | Notes | SWC |
|---|---|---|
| BC_METRICS_TASKCPUUSEMASK | STD_ON enables build of the task use masking functionality to excluded a user defined set of task CPU use times from the CPU use calculation. | |
| BC_METRICS_STACKUSE | STD_ON enables build of the Stack Use monitoring | Metrics |
| BC_METRICS_CPUUSEDIO | STD_ON enables build of the CPU Use digital output based monitoring | Metrics |
| BC_METRICS_CPUUSETMR | STD_ON enables build of the CPU Use timer based monitoring | Metrics |
| ENABLE_CPUUSE_DIO | If defined then CPU usage is output via a DIO where the DIO is high while the CPU is not in the background task. | Metrics |
| RTE_VFB_TRACE=1 | Enable Rte’s VFB trace functionality to support Rte_Task_Dispatch() hooks | Rte |
| Rte_Task_Dispatch | Enable Rte’s Rte_Task_Dispatch() hooks | Rte |
Generator Config
| Constant | Notes | SWC |
|---|---|---|
| Dio Channel Name: “Metrics” | Required when ENABLE_CPUUSE_DIO is defined | Dio |
| RTE VFB Trace Hooks |
Caveats:
| |
| MPU Global Read Access | GetSystemTime and Dio_WriteChannel Metrics Channel accessed registers must be readable across all application and ISR contexts. | Os |
| MPU Global Read/Write Access | Metrics data structures must be R/W across all application and ISR contexts. ATTENTION! The metrics data structures are very large, so ensure that adequate memory is allocated to the Global Shared region | OS |
Integration Project Changes
Modify the required BSW Irq source functions to place the Metrics_TaskStart and Metrics_TaskEnd hooks around the ISR’s. The recommended practice is to make a copy of the delivered source file renamed to *_NxtrMetrics.c and conditionaly build the altered file in place of the delivered file for Metrics builds.
Modify SchM.c to place the Metrics_TaskStart hook and Metrics_TaskEnd calls appropriately at around the tasks. Note that it might be necessary to place the hooks at a point in the task that will be overwritten when the SchM.c is generated. Diligence will need to used after generation to ensure that the hooks are not inadvertently removed.
Modify ApplCallbacks.c to place Metrics_TaskStart and Metrics_TaskEnd calls appropriately around tasks. Dilligence will be required to ensure the hooks are not removed.
Memory Mapping
Mapping
| Constant | Notes |
|---|---|
| METRICS_START_SEC_VAR_CLEARED_UNSPECIFIED | Writable across all applications |
* Each …START_SEC… constant is terminated by a …STOP_SEC… constant as specified in the AUTOSAR Memory Mapping requirements.
Usage
| Feature | RAM | ROM |
|---|---|---|
| Software task time stamping of task execution | ||
| Stack usage monitoring |
| Item # | Rev # | Change Description | Date | Author Initials |
|---|---|---|---|---|
| 1 |
1.3 - Metrics_MDD
Module --
(Above name of the module is a “Field” that can be updated. It should be set by going to File Properties – Custom and then modifying the Document name, this name will be the same one used for the filename also, refer design guidelines document, Once name modified, do a select all – and update entire document, so that this field will be updated everywhere it is used in the template, Remove this comment in the actual document)
High-Level Description
(Description must be within 8-10 lines.)
Figures
Diagram – Function Data Sharing
This diagram shows all data that is shared between functions within the module.
(Note – If no data is shared between functions, the Text “No Shared Data” can be used in place of a graphic. Also note that init functions need not be shown unless they compute non-zero data to be used by other functions in the module).
Diagram – Function (Name)
This diagram describes the functional characteristics and data flow of a given function.
(Note – This is not mandatory, only used where a graphical representation helps explain the function. It is left to the author’s discretion. New headers of this level (Level 3) should be created for each function.
Variable Data Dictionary
For details on module input / output variable, refer to the Data Dictionary for the application. Input / output variable names are listed here for reference.
(Note: Full variable names required in table.)
(Note: All global variables including End Of Line data used should be shown here)
| Module Inputs | Module Outputs | |
|---|---|---|
| <VarName_Units_Type> | <VarName_Units_Type> | |
Module Internal Variables
This section identifies the name, range and resolutions for module specific data created by this module. If there are no range restrictions on the variable, the term “FULL” is placed into the table for legal range.
| Variable Name | Resolution | Legal Range (min) | Legal Range (max) | Software Segment |
|---|---|---|---|---|
| <None> | ||||
User defined typedef definition/declaration
This section documents any user types uniquely used for the module.
| Typedef Name | Element Name | User Defined Type | Legal Range (min) | Legal Range (max) |
|---|---|---|---|---|
(Name given for the user defined typdef of type struct/union) (Variable name qualified similar to all other variables) | (Variable name qualified similar to all other variables) | as other variables | ||
| (Variable name qualified similar to all other variables) |
Constant Data Dictionary
Calibration Constants
This section lists the calibrations used by the module. For details on calibration constants, refer to the Data Dictionary for the application.
| Constant Name |
|---|
| <None> |
Program(fixed) Constants
Embedded Constants
All embedded constants whose values are provided in Eng units will be evaluated to the equivalent counts by using the FPM_InitFixedPoint_m() macro within the #define statement.
Local
| Constant Name | Resolution | Units | Value |
|---|---|---|---|
| <None> | |||
Global
This section lists the global constants used by the module. For details on global constants, refer to the Data Dictionary for the application.
| Constant Name |
|---|
| <None> |
Module specific Lookup Tables Constants
(This is for lookup tables (arrays) with fixed values, same name as other tables)
| Constant Name | Resolution | Value | Software Segment |
|---|---|---|---|
| None |
Functions/Macros used by the Sub-Modules
Library Functions / Macros
The library and functions / Macros that are called by the various sub modules are identified below,
<None>
Data Hiding Functions
<None>
Global Functions/Macros Defined by this Module
Global Function #1
| Function Name | (Exact name used) | Type | Min | Max | UTP Tol. |
|---|---|---|---|---|---|
| Arguments Passed | (if none, write None) | ||||
| (Insert more rows for additional passed arguments) | |||||
| Return Value | (if no value returned, write N/A) |
Description
(Place flowchart/design for local function)
Local Functions/Macros Used by this MDD only
Local Function #1
| Function Name | (Exact name used) | Type | Min | Max | UTP Tol. |
|---|---|---|---|---|---|
| Arguments Passed | (if none, write None) | ||||
| (Insert more rows for additional passed arguments) | |||||
| Return Value | (if no value returned, write N/A) |
Description
(Place flowchart/design for local function)
Software Module Implementation
Runtime Environment (RTE) Initial Values
This section lists the initial values of data written by this module but controlled by the RTE. After RTE initialization, the data in this table will contain these values.
| Data | Value |
|---|---|
| <None> |
Initialization Functions
(Note: For multiple init functions, insert new headers at the “Header 2” level – subset of “5.1 Initialization Functions” and follow the same sub-section design shown below)
Init: _L_Init(n)
Design Rationale
(Add design rationale specifically related to this FUNCTION. If none required, place the text “None”)
Module Outputs
(Initialize all module outputs in this section)
Module Internal
(Initialize all module internal variables in this section)
Periodic Functions
(Note: For multiple periodic functions, insert new headers at the “Header 2” level – subset of “5.2 Periodic Functions” and follow the same sub-section design shown below)
Per: _L_Per(n)
Design Rationale
(Add design rationale specifically related to this FUNCTION. If none required, place the text “None”)
Program Flow Start
(If program flow is required by the module, the function to store the unique identifier to a temporary variable is done here – start of the function)
Store Module Inputs to Local copies
(If not required based on design, insert text “None”)
(Processing of function)………
(Breakdown the function into smaller sections to add clarity to the design).
Store Local copy of outputs into Module Outputs
(If not required based on design, insert text “None”)
Program Flow End
(If program flow is required by the module, the function to add the temporary variable to the global accumulator is done here)
Fault Recovery Functions
(Note: For multiple functions, insert new headers at the “Header 2” level – subset of “5.3 Fault Recovery Functions” and follow the same sub-section design shown below)
FaultRec: _L_FaultRec(n)
Design Rationale
(Add design rationale specifically related to this FUNCTION. If none required, place the text “None”)
Program Flow Start
(If program flow is required by the module, the function to store the unique identifier to a temporary variable is done here – start of the function)
Store Module Inputs to Local copies
(If not required based on design, insert text “None”)
(Processing of function)………
(Breakdown the function into smaller sections to add clarity to the design).
Store Local copy of outputs into Module Outputs
(If not required based on design, insert text “None”)
Program Flow End
(If program flow is required by the module, the function to add the temporary variable to the global accumulator is done here)
Shutdown Functions
(Note: For multiple functions, insert new headers at the “Header 2” level – subset of “5.4 Shutdown Functions” and follow the same sub-section design shown below)
Shtdn: _L_Shtdn(n)
Design Rationale
(Add design rationale specifically related to this FUNCTION. If none required, place the text “None”)
Program Flow Start
(If program flow is required by the module, the function to store the unique identifier to a temporary variable is done here – start of the function)
Store Module Inputs to Local copies
(If not required based on design, insert text “None”)
(Processing of function)………
(Breakdown the function into smaller sections to add clarity to the design).
Store Local copy of outputs into Module Outputs
(If not required based on design, insert text “None”)
Program Flow End
(If program flow is required by the module, the function to add the temporary variable to the global accumulator is done here)
Interrupt Functions
(Note: For multiple functions, insert new headers at the “Header 2” level – subset of “5.5 Interrupt Functions” and follow the same sub-section design shown below)
Isr: _L_Isr(n)
Design Rationale
(Add design rationale specifically related to this FUNCTION. If none required, place the text “None”)
(Processing of the ISR function)…..
(Note: Multiple headings can be used to break apart the functionality)
Serial Communication Functions
(Note: For multiple functions, insert new headers at the “Header 2” level – subset of “5.6 Serial Communication Functions” and follow the same sub-section design shown below)
SComm: _L_SComm(n)
Design Rationale
(Add design rationale specifically related to this FUNCTION. If none required, place the text “None”)
Program Flow Start
(If program flow is required by the module, the function to store the unique identifier to a temporary variable is done here – start of the function)
Store Module Inputs to Local copies
(If not required based on design, insert text “None”)
(Processing of function)………
(Breakdown the function into smaller sections to add clarity to the design).
Store Local copy of outputs into Module Outputs
(If not required based on design, insert text “None”)
Program Flow End
(If program flow is required by the module, the function to add the temporary variable to the global accumulator is done here)
Execution Requirements
Execution Sequence of the Module
(Describe in words relevant details about the execution sequence of the different sub modules.)
Execution Rates for sub-modules called by the Scheduler
This table serves as reference for the Scheduler design
| Function Name | Calling Frequency | System State(s) in which the function is called |
|---|---|---|
| <None> |
Execution Requirements for Serial Communication Functions
| Function Name | Sub-Module called by (Serial Comm Function Name) |
|---|---|
| <None> |
Memory Map Definition Requirements
Sub Modules (Functions)
This table identifies the software segments for functions identified in this module.
| Name of Sub Module | Software Segment |
|---|---|
Local Functions
This table identifies the software segments for local functions identified in this module.
| Name of Sub Module | Software Segment |
|---|---|
Known Issues / Limitations With Design
(Item #1)
Revision Control Log
| Item # | Rev # | Change Description | Date | Author Initials |
|---|---|---|---|---|
| 1 |
2 - Nexteer Library
Nexteer Library
Component Documentation
- Filter_Library_Design_Document.html
- Interpolation_Design_MDD.html
- NxtrLib_Systemtime Integration_Manual.html
Unit Test Plan
2.1 - Filter_Library_Design_Document
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.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
2 1st Order Low Pass Filter, 1 Pole- coefficient 7
2.1.2 Library Routines Design 8
2.2.2 Library Routines Design 15
2.3 Topology 3 – 1LP1-CF (Floating Point Implementation) 20
2.3.1.1 Coefficient K Calculation and State Variable Initialization 20
2.3.1.2 Coefficient K Recalculation 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 1st Order High Pass Filter, 1 Pole- coefficient 23
3.1 Topology 1 – HP-CF (Floating Point Implementation) 23
3.1.1.1 Coefficient K Calculation and State Variable Initialization 23
3.1.1.2 Coefficient K Recalculation 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
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
| Function Name | NF_Init_f32 | Type | Min | Max | UTP Tol. |
| Arguments Passed | In_Uls_T_f32 – Initial input to the filter | Float 32 | |||
| SVPtr_Cnt_T_Str – Pointer to state variable struct | NotchFiltSV_Str | ||||
| FiltK_Cnt_T_Str – Pointer to coefficient structure | NotchFiltK_Str | **See 1.3 | |||
| Return Value | N/A | ||||
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
| Function Name | NF_SvUpdate_f32 | Type | Min | Max | UTP Tol. |
| Arguments Passed | In_Uls_T_f32 – Input to notch filter | Float 32 | |||
| SVPtr_T_Cnt_Str – Pointer to state variable struct | NotchFiltSV_Str | **See 1.3 | |||
| FiltK_Cnt_T_Str – Pointer to filter cal struct | NotchFiltK_Str | **See 1.3 | |||
| Return Value | N/A | ||||
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
| Function Name | NF_OpUpdate_f32 | Type | Min | Max | UTP Tol. |
| Arguments Passed | In_Uls_T_f32 – Input to the notch filter | Float 32 | |||
| SVPtr_T_Cnt_Str – Pointer to state variable struct | NotchFiltSV_Str | **See 1.3 | |||
| Return Value | Filtered Output, SV Structure Updated | Float 32 | |||
Pseudo Code:
Out = SV1 + (B0 * In);
Notch Filter Full Update Function
| Function Name | NF_FullUpdate_f32 | Type | Min | Max | UTP Tol. |
| Arguments Passed | In_Uls_T_f32 – Input to notch filter | Float 32 | |||
| SVPtr_Cnt_T_Str – Pointer to state variable struct | NotchFiltSV_Str | **See 1.3 | |||
| FiltK_Cnt_T_Str – Pointer to filter cal struct | NotchFiltK_Str | **See 1.3 | |||
| Return Value | Filtered output | Float 32 | |||
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
| Structure Name | NotchFiltSV_Str | Type | Min | Max | UTP Tol. |
| Members | SV1_Uls_f32 | Float 32 | FULL | FULL | |
| SV2_Uls_f32 | Float 32 | FULL | FULL | ||
| Out_Uls_f32 | Float 32 | FULL | FULL | ||
| KPtr_Cnt_Str | KPtr_Cnt_Str | **See Below | |||
| Structure Name | NotchFiltK_Str | Type | Min | Max | UTP Tol. |
| Members | A1_Uls_f32 | Float 32 | |||
| A2_Uls_f32 | Float 32 | ||||
| B0_Uls_f32 | Float 32 | ||||
| B1_Uls_f32 | Float 32 | ||||
| B2_Uls_f32 | Float 32 |
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>);
1st Order Low Pass Filter, 1 Pole- coefficient
Topology 1 – 1LP1-C
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 – “1st 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
| Symbol | Description | Constant Classification |
| Kn | Numerator of Filter Coefficient | This may be defined as a calibration constant or an embedded local constant based on the usage. |
| Kd | Denominator of Filter Coefficient | Based on the implementation, this value may be a fixed value, which is embedded within the library function/macro or could be passed as a parameter. |
| Node Symbol | Description |
| I | Input |
| e | State Variable (filt_SV) |
| O | Output (filt_O) |
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.
| Node Symbol | Description | Data Type |
| I | Input | UINT 16 |
| c | UINT16 | |
| d | UINT32 | |
| e | State Variable (filt_SV) | UINT 32 |
| f | UINT16 | |
| O | Output (filt_O) | UINT 16 |
State Variable Initialization Macro
| Function Name | LPF_SvInit_u16InFixKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to the low pass filter | UINT16 | |||
| Return Value | Initialized value of node e | UINT32 |
Pseudo Code:
Lvalue = Input << Kd
where Kd is pre-defined for a fixed16 bit filter coefficient = 16 bits
Filter Output Initialization Macro
| Function Name | LPF_OpInit_u16InFixKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to the low pass filter | UINT16 | |||
| Filt_SV – Initialized value of the state variable | UINT32 | ||||
| Kn - Numerator of the filter coefficient | UINT16 | ||||
| Return Value | Initialized output of the low pass filter | UINT32 |
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
| Function Name | LPF_SvUpdate_u16InFixKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to the low pass filter | UINT16 | |||
| Filt_SV – Calculated value of the state variable | UINT32 | ||||
| Kn - Numerator of the filter coefficient | UINT16 | ||||
| Return Value | Output of the low pass filter | UINT32 |
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
| Function Name | LPF_OpUpdate_u16InFixKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Filt_SV – Calculated value of the state variable | UINT32 | |||
| Return Value | Output of the low pass filter | UINT16 |
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.
| Node Symbol | Description | Data Type |
| I | Input | SINT 16 |
| c | SINT 16 | |
| d | SINT 32 | |
| e | State Variable (filt_SV) | SINT 32 |
| f | SINT 16 | |
| O | Output (filt_O) | SINT 16 |
State Variable Initialization Macro
| Function Name | LPF_SvInit_s16InFixKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to the low pass filter | SINT16 | |||
| Return Value | Initilized value of Node e | SINT32 |
Pseudo Code:
Lvalue = Input << Kd
where Kd is pre-defined for a 16 bit filter coefficient as 16 bits
Filter Output Initialization Macro
| Function Name | LPF_OpInit_s16InFixKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to the low pass filter | SINT16 | |||
| Filt_SV – Initialized value of the state variable | SINT32 | ||||
| Kn – Numerator of the filter coefficient | SINT16 | ||||
| Return Value | Initialized value of filter output | SINT32 |
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
| Function Name | LPF_SvUpdate_s16InFixKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to the low pass filter | SINT16 | |||
| Filt_SV – Initialized value of the state variable | SINT32 | ||||
| Kn – Numerator of the filter coefficient | SINT16 | ||||
| Return Value | Calculated value of filt_SV | SINT32 |
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
| Function Name | LPF_OpUpdate_s16InFixKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Filt_SV – calculated value of filter state variable | SINT32 | |||
| Return Value | Output of the low pass filter | SINT16 |
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
| Node Symbol | Description | Data Type |
| I | Input | UINT 16 |
| a | UINT 16 | |
| b | UINT 16 | |
| c | UINT 16 | |
| d | UINT 32 | |
| e | State Variable (filt_SV) | UINT 32 |
| f | UINT 16 | |
| g | UINT 16 | |
| O | Output (filt_O) | UINT 16 |
State Variable Initialization Macro
| Function Name | LPF_SvInit_u16InVarKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to the low pass filter | UINT16 | |||
| Kd – Denominator bits of filter coefficient | UINT16 | ||||
| D – Deadband factor | UINT16 | ||||
| Return Value | Initialized value of Node e | UINT32 |
Pseudo Code:
Lvalue = (Input << Kd) << D
Note:- The multiplication by D shall not be performed for D = 0.
Filter Output Initialization Macro
| Function Name | LPF_OpInit_u16InVarKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to the low pass filter | UINT16 | |||
| Filt_SV – Initialized value of state variable | UINT32 | ||||
| Kn – Numerator of coefficient | UINT16 | ||||
| Kd – Denominator bits of filter coefficient | UINT16 | ||||
| D – Deadband factor | UINT16 | ||||
| Return Value | Low pass filter output | UINT32 |
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
| Function Name | LPF_SvUpdate_u16InVarKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to the low pass filter | UINT16 | |||
| Filt_SV – Calculated value of filter state variable | UINT32 | ||||
| Kn – Numerator of coefficient | UINT16 | ||||
| Kd – Denominator bits of filter coefficient | UINT16 | ||||
| D – Deadband factor | UINT16 | ||||
| Return Value | Low pass filter output | UINT32 |
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
| Function Name | LPF_OpUpdate_u16InVarKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Filt_SV – Calculated value of filter state variable | UINT32 | |||
| Kd – Denominator bits of filter coefficient | UINT16 | ||||
| D – Deadband factor | UINT16 | ||||
| Return Value | Low pass filter output | UINT32 |
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
| Node Symbol | Description | Data Type |
| I | Input | SINT 16 |
| a | SINT 16 | |
| b | SINT 16 | |
| c | SINT 16 | |
| d | SINT 32 | |
| e | State Variable (filt_SV) | SINT 32 |
| f | SINT 16 | |
| g | SINT 16 | |
| O | Output (filt_O) | SINT 16 |
State Variable Initialization Macro
| Function Name | LPF_SvInit_s16InVarKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to the low pass filter | SINT16 | |||
| Kd – Denominator bits of filter coefficient | SINT16 | ||||
| D – Deadband factor | SINT16 | ||||
| Return Value | Initialized value of Node e | SINT32 |
Pseudo Code:
Lvalue = (Input << Kd) << D
Note:- The multiplication by D shall not be performed for D = 0.
Filter Output Initialization Macro
| Function Name | LPF_OpInit_s16InVarKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to the low pass filter | SINT16 | |||
| Filt_SV – Initialized value of filter state variable | SINT32 | ||||
| Kn – Numerator of filter coefficient | SINT16 | ||||
| Kd – Denominator bits of filter coefficient | SINT16 | ||||
| D – Deadband factor | SINT16 | ||||
| Return Value | Initialized value of filter output | SINT32 |
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
| Function Name | LPF_SvUpdate_s16InVarKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to the low pass filter | SINT16 | |||
| Filt_SV – Calculated value of filter state variable | SINT32 | ||||
| Kn – Numerator of filter coefficient | SINT16 | ||||
| Kd – Denominator bits of filter coefficient | SINT16 | ||||
| D – Deadband factor | SINT16 | ||||
| Return Value | Calculated value of filt_SV as given below | SINT32 |
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
| Function Name | LPF_OpUpdate_s16InVarKTrunc_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Filt_SV – Calculated value of filter state variable | SINT32 | |||
| Kd – Denominator bits of filter coefficient | SINT16 | ||||
| D – Deadband factor | SINT16 | ||||
| Return Value | Low pass filter output | SINT32 |
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
| Function Name | LPF_Init_f32_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Initial input to filter | Float 32 | FULL | FULL | |
| Fp – Pole cutoff frequency in hertz | Float 32 | 0.1% 1/T | 50% 1/T | ||
| T – Sampling interval in seconds | Float 32 | 0.00005 | 10 | ||
| SV_Str – Pointer to the state variable structure | LPF32KSV_Str | *See 2.3.2.1.4 | |||
| Return Value | Initial output, node O | Float 32 | FULL | FULL | |
Pseudo Code:
<SV_Str-> SV_Uls_f32> = Input
<Lvalue> = Input
LPF_KUpdate_f32_m(Fp, T, SV_Str)
Coefficient Recalculation Macro
| Function Name | LPF_KUpdate_f32_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Fp – Pole cutoff frequency in hertz | Float 32 | 0.1% 1/T | 50% 1/T | |
| T – Sampling interval in seconds | Float 32 | 0.00005 | 10 | ||
| SV_Str – Pointer to the state variable structure | LPF32KSV_Str | *See 2.3.2.1.4 | |||
| Return Value | New value of K stored in state variable structure | Float 32 | 0.0 | 1.0 | |
Pseudo Code:
<SV_Str-> K_Uls_f32> = 1 – expf(-2π * Fp * T)
Output Update Macro
| Function Name | LPF_OpUpdate_f32_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to low pass filter | Float 32 | FULL | FULL | |
| SV_Str – Pointer to the state variable structure | LPF32KSV_Str | *See 2.3.2.1.4 | |||
| Return Value | Output of low pass filter | Float 32 | FULL | FULL | |
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
| LPF32KSV_Str | Type | Min | Max | UTP Tol. |
| K_Uls_f32 | Float 32 | 0.0 | 1.0 | |
| SV_Uls_f32 | Float 32 | FULL | FULL |
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>)
1st 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
| Function Name | HPF_Init_f32_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Initial input to filter | Float 32 | FULL | FULL | |
| Fp – Pole cutoff frequency in hertz | Float 32 | 0.1% 1/T | 50% 1/T | ||
| T – Sampling interval in seconds | Float 32 | 0.00005 | 10 | ||
| SV_Ptr – Pointer to the state variable structure | HPF32KSV_Str | *See 3.1.2.1.4 | |||
| Return Value | Assignment returns initial output | ||||
Pseudo Code:
LPF_Init_f32_m(Input, Fp, T, &(SV_Ptr->LPF_Str))
HPF_KUpdate_f32_m(Fp, T, SV_Ptr)
Coefficient Recalculation Macro
| Function Name | HPF_KUpdate_f32_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Fp – Pole cutoff frequency in hertz | Float 32 | 0.1% 1/T | 50% 1/T | |
| T – Sampling interval in seconds | Float 32 | 0.00005 | 10 | ||
| SV_Ptr – Pointer to the state variable structure | HPF32KSV_Str | *See 3.1.2.1.4 | |||
| Return Value | Assignment returns correction factor | ||||
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
| Function Name | HPF_OpUpdate_f32_m | Type | Min | Max | UTP Tol. |
| Arguments Passed | Input – Input to low pass filter | Float 32 | FULL | FULL | |
| SV_Ptr – Pointer to the state variable structure | HPF32KSV_Str | *See 3.1.2.1.4 | |||
| Return Value | Assignment returns filter output | ||||
Pseudo code:
(Input - LPF_OpUpdate_f32_m(input_f32, &(SV_Ptr->LPF_Str))) * SV_Ptr->CF_Uls_f32
Usable ranges for HPF32KSV_Str Structure
| HPF32KSV_Str | Type | Min | Max | UTP Tol. |
| LPF_Str | LPF32KSV_Str | *See 2.3.2.1.4 | ||
| CF_Uls_f32 | Float 32 | 0.0 | FULL | |
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
| # | Rev | Change | Date | Author |
| 1 | 1.0 | Added floating point low-pass filter | 09FEB12 | Jared Julien |
| 2 | 2.0 | Added floating point high-pass filter, fixed issues in FP LPF | 26-Apr-12 | Owen Tosh |
| 3 | 3.0 | Correct output types for some filters (32 bits output instead of 16bits) – no code change | 25-Jan-13 | D. Djena |
| 4 | 4.0 | Added new parameter to functions NF_FullUpdate_f32 and NF_SvUpdate_f32 | 05-Dec-13 | VT |
2.2 - Interpolation_Design_MDD
1 Variable X Variable Y 2D Table Lookup function (with interpolation) 2
1.2.1 Unsigned X, Unsigned Y 4
2 Fixed X Variable Y 2D Table Lookup function (with interpolation) 11
2.2.1 Unsigned X, Unsigned Y 11
3 Single X Multiple Y (Bilinear Interpolation) 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.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
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.
(yn+1 - yn) = interval in the dependent table within which the interpolated output is calculated.
(xn+1 - xn) = interval in the independent table within which the input lies.
y = interpolated output (dependent variable)
x = input (independent variable)
Note that yn+1 < yn or yn+1 > yn, for negative or positive slopes and xn+1 > xn.
The index n and n+1, are determined using Straight-Forward Search method. Using the indices, the values of xn+1, xn, yn+1 and yn are determined.
The difference (yn+1 - yn) 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
(yn+1 - yn) = 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 xn, yn and yn+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:
BS:- Bilinear Selector
Input:-The input to the table
BSTbl:- Bilinear Selector Table 2D
BSize:- Bilinear Selector Table Size
XTbl:- Table X 2D
YMTbl:- Table Y with MxN dimension
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
BS:- Bilinear Selector
input:-The input to the table
BSTbl:- Bilinear Selector Table 2D
BSize:- Bilinear Selector Table Size
XTbl:- Table X 2D
YMTbl:- Table Y with MxN dimension
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:
BS:- Bilinear Selector
Input:-The input to the table
BSTbl:- Bilinear Selector Table 2D
BSize:- Bilinear Selector Table Size
XTbl:- Table X 2D
YMTbl:- Table Y with MxN dimension
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
BS:- Bilinear Selector
input:-The input to the table
BSTbl:- Bilinear Selector Table 2D
BSize:- Bilinear Selector Table Size
XTbl:- Table X 2D
YMTbl:- Table Y with MxN dimension
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:
BS:- Bilinear Selector
input:-The input to the table
BSTbl:- Bilinear Selector Table 2D
BSize:- Bilinear Selector Table Size
XTbl:- Table X with [MxN] dimension
YMTbl:- Table Y with [MxN] dimension
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:
BS:- Bilinear Selector
input:-The input to the table
BSTbl:- Bilinear Selector Table 2D
BSize:- Bilinear Selector Table Size
XTbl:- Table X with [MxN] dimension
YMTbl:- Table Y with [MxN] dimension
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:
BS:- Bilinear Selector
input:-The input to the table
BSTbl:- Bilinear Selector Table 2D
BSize:- Bilinear Selector Table Size
XTbl:- Table X with [MxN] dimension
YMTbl:- Table Y with [MxN] dimension
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:
BS:- Bilinear Selector
input:-The input to the table
BSTbl:- Bilinear Selector Table 2D
BSize:- Bilinear Selector Table Size
XTbl:- Table X with [MxN] dimension
YMTbl:- Table Y with [MxN] dimension
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
| Item # | Rev # | Change Description | Date | Author Initials |
| 1 | CBD | Interpolation MDD | 13 April 12 | NRAR |
| 2 | 2 | Added remaining bilinear interpolation functions | 28-Sep-12 | OT |
| 3 | 3 | Changed divide by zero logic in bilinear interpolation to prevent floating point exceptions | 21-Mar-13 | LWW |
2.3 - NxtrLib_Systemtime Integration_Manual
Contents
Dependencies
| Module | Required Feature |
|---|---|
Configuration
Build Time Config
| Constant | Notes | SWC |
|---|---|---|
Generator Config
System
| Constant | Notes | SWC |
|---|---|---|
Integration
The following import steps must be completed:
Place CBD project structure to appropriate integration folder
Copy SystemTime_Cfg.h.tt into the Header folder and remove the .tt extension.
Configure the constant D_TickRate_Cnt_u32 to the appropriate Os system tick time.
Runnable Scheduling
This section specifies the required runnable scheduling.
| Runnable | Scheduling Requirements | Trigger |
|---|---|---|
Memory Mapping
Mapping
| Constant | Notes |
|---|---|
* Each …START_SEC… constant is terminated by a …STOP_SEC… constant as specified in the AUTOSAR Memory Mapping requirements.
Usage
| Feature | RAM | ROM |
|---|---|---|
| Full driver |
Revision Control Log
| Item # | Rev # | Change Description | Date | Author Initials |
|---|---|---|---|---|
| 1 | Initial version | 26Jul13 | SAH |
2.4 - Interpolation_UnitTestResults
Overview
Unit Test InformationModule Definitions
Variable Range
BilinearXYM_s16_u16Xs16YM_Cnt
BilinearXYM_s16_u16Xs16YM_Cnt P
BilinearXYM_s16_u16Xs16YM_Cnt B
BilinearXYM_u16_u16Xu16YM_Cnt
BilinearXYM_u16_u16Xu16YM_Cnt P
BilinearXYM_u16_u16Xu16YM_Cnt B
BilinearXMYM_u16_u16XMu16YM_Cnt
BilinearXMYM_u16_u16XMu16YM_C P
BilinearXMYM_u16_u16XMu16YM_C B
BilinearXMYM_s16_u16XMs16YM_Cnt
BilinearXMYM_s16_u16XMs16YM_C P
BilinearXMYM_s16_u16XMs16YM_C B
BilinearXMYM_s16_s16XMs16YM_Cnt
BilinearXMYM_s16_s16XMs16YM_C P
BilinearXMYM_s16_s16XMs16YM_C B
IntplVarXY_u16_u16Xu16Y_Cnt
IntplVarXY_u16_u16Xu16Y_Cnt() P
IntplVarXY_u16_u16Xu16Y_Cnt() B
IntplVarXY_u16_s16Xu16Y_Cnt
IntplVarXY_u16_s16Xu16Y_Cnt() P
IntplVarXY_u16_s16Xu16Y_Cnt() B
IntplVarXY_s16_s16Xs16Y_Cnt
IntplVarXY_s16_s16Xs16Y_Cnt() P
IntplVarXY_s16_s16Xs16Y_Cnt() B
IntplVarXY_s16_u16Xs16Y_Cnt
IntplVarXY_s16_u16Xs16Y_Cnt() P
IntplVarXY_s16_u16Xs16Y_Cnt() B
IntplFxdX_u16_u16Xu16Y_Cnt
IntplFxdX_u16_u16Xu16Y_Cnt() P
IntplFxdX_u16_u16Xu16Y_Cnt() B
IntplFxdX_u16_s16Xu16Y_Cnt
IntplFxdX_u16_s16Xu16Y_Cnt() P
IntplFxdX_u16_s16Xu16Y_Cnt() B
IntplFxdX_s16_s16Xs16Y_Cnt
IntplFxdX_s16_s16Xs16Y_Cnt() P
IntplFxdX_s16_s16Xs16Y_Cnt() B
IntplFxdX_s16_u16Xs16Y_Cnt
IntplFxdX_s16_u16Xs16Y_Cnt() P
IntplFxdX_s16_u16Xs16Y_Cnt() B
Sheet 1: Unit Test Information
Sheet 2: Module Definitions
| |||||||||||
| 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] | |||||||||
Sheet 3: Variable Range
| |||||||||||
| 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] | |||||||||||
Sheet 4: BilinearXYM_s16_u16Xs16YM_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| BilinearXYM_s16_u16Xs16YM_Cnt | B | 21 | BilinearXYM_s16_u16Xs16YM_Cnt_BSTbl[3] | ||
| BilinearXYM_s16_u16Xs16YM_Cnt | P | 7 | BilinearXYM_s16_u16Xs16YM_Cnt_XTbl[3] | ||
| BilinearXYM_s16_u16Xs16YM_Cnt_YMTbl1[3] | |||||
| BilinearXYM_s16_u16Xs16YM_Cnt_YMTbl2[3] | |||||
| BilinearXYM_s16_u16Xs16YM_Cnt_YMTbl3[3] | |||||
Sheet 5: BilinearXYM_s16_u16Xs16YM_Cnt P
| BilinearXYM_s16_u16Xs16YM_Cnt | TS | -- | |||||||||||||
| P | Param1 | Param2 | Param3 | Param4 | I/P5 | I/P6 | I/P7 | I/P8 | I/P9 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | BS1 | input1 | BSsize1 | Xsize1 | 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_s16_u16Xs16YM_Cnt | BilinearXYM_s16_u16Xs16YM_Cnt | P/F | CPU Cycles | |
| 1 | (BS <= BSTbl[0]) = True and (input <= XTbl[0])=False and (input >= XTbl[Xsize-1])=True and ((sint32)(Denominator_f32) == 0)=True and (Output_f32>=0)=False | 0 | 5645 | 3 | 3 | 7432 , 7432 , 7432 | 2222 ,2222 ,2222 | -12345, -12345 , -12345 | -6459, -6459 ,-6459 | 4232, 4232 ,4232 | -- | -12345 | -- | ||
| 2 | (BS <= BSTbl[0]) = False and (BS >= BSTbl[BSsize-1])=True and ((BSTbl[BSindex] == BSTbl[BSindex+1] = True && (BSindex > 0))) = True and ((BSTbl[BSindex] == BSTbl[BSindex+1] = True && (BSindex > 0)))=False | 65535 | 8678 | 3 | 3 | 26327 , 26327 ,26327 | 4633 , 4633 ,4633 | -2637, -2637 ,-2637 | 4232, 4232 ,4232 | 2521 , 2521 ,2521 | -- | -2637 | -- | ||
| 3 | (input <= XTbl[0])=True and (Output_f32>=0)=True | 1000 | 3453 | 3 | 3 | 37382 , 37382 , 37382 | 6478 , 6478 ,6478 | 8546, 8546 ,8546 | 2521 , 2521 ,2521 | 1312 , 1312 ,1312 | -- | 8546 | -- | ||
| 4 | (BS >= BSTbl[BSsize-1])=False and ( BSTbl[BSindex+1] < BS )=True and ( BSTbl[BSindex+1] < BS )=False | 65530 | 8678 | 3 | 3 | 26327 , 26327 ,65531 | 4633 , 4633 ,4633 | -2637, -2637 ,-2637 | 4232, 4232 ,4232 | 2521 , 2521 ,2521 | -- | 4232 | -- | ||
| 5 | ((BSTbl[BSindex] == BSTbl[BSindex+1] = False&& (BSindex > 0))) | 65530 | 8678 | 3 | 3 | 26327 , 26327 ,65529 | 4633 , 4633 ,4633 | -2637, -2637 ,-2637 | 4232, 4232 ,4232 | 2521 , 2521 ,2521 | -- | 4232 | -- | ||
| 6 | (input >= XTbl[Xsize-1])=False and ( XTbl[Xindex+1] < input )=True and ( XTbl[Xindex+1] < input )=False | 0 | 5645 | 3 | 3 | 7432 , 7432 , 7432 | 2222 ,2222 ,5646 | -12345, -12345 , -12345 | -6459, -6459 ,-6459 | 4232, 4232 ,4232 | -- | -12345 | -- | ||
| 7 | ((sint32)(Denominator_f32) == 0)=False | 0 | 5645 | 3 | 3 | 7430 , 7432 , 7432 | 2222 ,2220 ,2222 | -12345, -12345 , -12345 | -6459, -6459 ,-6459 | 4232, 4232 ,4232 | -- | -12345 | -- | ||
Sheet 6: BilinearXYM_s16_u16Xs16YM_Cnt B
| BilinearXYM_s16_u16Xs16YM_Cnt | TS | -- | |||||||||||||
| B | Param1 | Param2 | Param3 | Param4 | I/P5 | I/P6 | I/P7 | I/P8 | I/P9 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | BS1 | input1 | BSsize1 | Xsize1 | 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_s16_u16Xs16YM_Cnt | BilinearXYM_s16_u16Xs16YM_Cnt | P/F | CPU Cycles | |
| 1 | param 1 min | 0 | 5645 | 3 | 3 | 7432 , 7432 , 7432 | 2222 ,2222 ,2222 | -12345, -12345 , -12345 | -6459, -6459 ,-6459 | 4232, 4232 ,4232 | -- | -12345 | -- | ||
| 2 | param 1 max | 65535 | 8678 | 3 | 3 | 26327 , 26327 ,26327 | 4633 , 4633 ,4633 | -2637, -2637 ,-2637 | 4232, 4232 ,4232 | 2521 , 2521 ,2521 | -- | -2637 | -- | ||
| 3 | param 1 pos | 1000 | 3453 | 3 | 3 | 37382 , 37382 , 37382 | 6478 , 6478 ,6478 | 8546, 8546 ,8546 | 2521 , 2521 ,2521 | 1312 , 1312 ,1312 | -- | 8546 | -- | ||
| 4 | param 2 min | 1234 | 0 | 3 | 3 | 42769 , 42769 ,42769 | 3333 , 3333 ,3333 | -9484, -9484 ,-9484 | 1312 , 1312 ,1312 | -2637, -2637 ,-2637 | -- | -9484 | -- | ||
| 5 | param 2 max | 2345 | 65535 | 3 | 3 | 52636 , 52636 ,52636 | 4444 , 4444 ,4444 | -3744, -3744 , -3744 | -2637, -2637 ,-2637 | 8546, 8546 ,8546 | -- | -3744 | -- | ||
| 6 | param 2 pos | 3456 | 2000 | 3 | 3 | 5555 , 5555 ,5555 | 5555 , 5555 ,5555 | 17633, 17633 ,17633 | 8546, 8546 ,8546 | -9484, -9484 ,-9484 | -- | 17633 | -- | ||
| 7 | param 3 default | 4567 | 4342 | 3 | 3 | 3637 , 3637 ,3637 | 3637 , 3637 ,3637 | 26385, 26385 ,26384 | -9484, -9484 ,-9484 | -3744, -3744 ,-3744 | -- | 26385 | -- | ||
| 8 | param 4 default | 5678 | 7764 | 3 | 3 | 2754 , 2754 ,2754 | 2754 , 2754 ,2754 | -7236, -7236 ,-7236 | -3744, -3744 ,-3744 | 17633, 17633 ,17633 | -- | -7236 | -- | ||
| 9 | I/p 5 min | 6789 | 1234 | 3 | 3 | 0, 0 ,0 | 7432 , 7432 , 7432 | 5820, 5820 ,5820 | 17633, 17633 ,17633 | 26385, 26385 ,26385 | -- | 5820 | -- | ||
| 10 | I/p 5 max | 8908 | 7897 | 3 | 3 | 65535 ,65535 ,65535 | 26327 , 26327 ,26327 | 17552, 17552 ,17552 | 26385, 26385 ,26385 | -7236, -7236 ,-7236 | -- | 17552 | -- | ||
| 11 | I/p 5 pos | 1111 | 2345 | 3 | 3 | 1000, 1000 ,1000 | 37382 , 37382 , 37382 | 27544, 27544 ,27544 | -7236, -7236 ,-7236 | 5820, 5820 ,5820 | -- | 27544 | -- | ||
| 12 | I/p 6 min | 2222 | 3456 | 3 | 3 | 2222 ,2222 ,2222 | 0, 0 ,0 | -6439, -6439 ,-6439 | 5820, 5820 ,5820 | 17552, 17552 ,17552 | -- | -6439 | -- | ||
| 13 | I/p 6 max | 3333 | 4567 | 3 | 3 | 4633 , 4633 ,4633 | 65535 ,65535 ,65535 | -6459, -6459 ,-6459 | 17552, 17552 ,17552 | 27544, 27544 ,27544 | -- | -6459 | -- | ||
| 14 | I/p 6 pos | 4444 | 5678 | 3 | 3 | 6478 , 6478 ,6478 | 2000, 2000 ,2000 | 4232, 4232 ,4232 | 27544, 27544 ,27544 | -6439, -6439 ,-6439 | -- | 4232 | -- | ||
| 15 | I/p 7 min | 5555 | 6789 | 3 | 3 | 3333 , 3333 ,3333 | 42769 , 42769 ,42769 | -32768, -32768 ,-32768 | -6439, -6439 ,-6439 | -6459, -6459 ,-6459 | -- | -32768 | -- | ||
| 16 | I/p 7 max | 6666 | 8908 | 3 | 3 | 4444 , 4444 ,4444 | 52636 , 52636 ,52636 | 32767, 32767 ,32767 | -6459, -6459 ,-6459 | 4232, 4232 ,4232 | -- | 32767 | -- | ||
| 17 | I/p 7 zero | 7777 | 1111 | 3 | 3 | 5555 , 5555 ,5555 | 5555 , 5555 ,5555 | 0, 0 ,0 | 4232, 4232 ,4232 | 2521 , 2521 ,2521 | -- | 0 | -- | ||
| 18 | I/p 7 neg | 8888 | 2222 | 3 | 3 | 3637 , 3637 ,3637 | 3637 , 3637 ,3637 | -1500, -1500 ,-1500 | 2521 , 2521 ,2521 | 1312 , 1312 ,1312 | -- | -1500 | -- | ||
| 19 | I/p 7 pos | 9999 | 4234 | 3 | 3 | 2754 , 2754 ,2754 | 2754 , 2754 ,2754 | 1800, 1800 ,1800 | 1312 , 1312 ,1312 | -6459, -6459 ,-6459 | -- | 1800 | -- | ||
| 20 | All min | 0 | 0 | 3 | 3 | 0, 0 ,0 | 0, 0 ,0 | -32768, -32768 ,-32768 | -32768, -32768 ,-32768 | -32768, -32768 ,-32768 | -- | -32768 | -- | ||
| 21 | All max | 65535 | 65535 | 3 | 3 | 65535 ,65535 ,65535 | 65535 ,65535 ,65535 | 32767, 32767 ,32767 | 32767, 32767 ,32767 | 32767, 32767 ,32767 | -- | 32767 | -- | ||
Sheet 7: BilinearXYM_u16_u16Xu16YM_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| BilinearXYM_u16_u16Xu16YM_Cnt | B | 19 | BilinearXYM_u16_u16Xu16YM_Cnt_BSTbl[3] | ||
| BilinearXYM_u16_u16Xu16YM_Cnt | P | 9 | BilinearXYM_u16_u16Xu16YM_Cnt_XTbl[3] | ||
| BilinearXYM_u16_u16Xu16YM_Cnt_YMTbl1[3] | |||||
| BilinearXYM_u16_u16Xu16YM_Cnt_YMTbl2[3] | |||||
| BilinearXYM_u16_u16Xu16YM_Cnt_YMTbl3[3] | |||||
Sheet 8: BilinearXYM_u16_u16Xu16YM_Cnt P
| BilinearXYM_u16_u16Xu16YM_Cnt | TS | -- | |||||||||||||
| P | Param1 | Param2 | Param3 | Param4 | I/P5 | I/P6 | I/P7 | I/P8 | I/P9 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | BS2 | input2 | BSsize2 | Xsize2 | 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] | BilinearXYM_u16_u16Xu16YM_Cnt | BilinearXYM_u16_u16Xu16YM_Cnt | P/F | CPU Cycles | |
| 1 | (BS <= BSTbl[0])=True and (input <= XTbl[0])=True and ((sint32)Denominator_f32 == 0)=True | 0 | 7980 | 3 | 3 | 2222 ,2222 ,2222 | 37382 , 37382 , 37382 | 2521 , 2521 ,2521 | 4232, 4232 ,4232 | 12345, 12345 , 12345 | -- | 2521 | -- | ||
| 2 | (BS <= BSTbl[0])=False and (BS >= BSTbl[BSsize-1])=True and ((BSTbl[BSindex] == BSTbl[BSindex+1] = True && (BSindex > 0)))=True and ((BSTbl[BSindex] == BSTbl[BSindex+1] =True && (BSindex > 0)))=False | 65535 | 5455 | 3 | 3 | 4633 , 4633 ,4633 | 42769 , 42769 ,42769 | 4232, 4232 ,4232 | 2521 , 2521 ,2521 | 2637, 2637 ,2637 | -- | 4232 | -- | ||
| 3 | (input <= XTbl[0])=False and (input >= XTbl[Xsize-1])=True | 5645 | 65535 | 3 | 3 | 4444 , 4444 ,4444 | 1000, 1000 ,1000 | 2637, 2637 ,2637 | 8546, 8546 ,8546 | 3744, 3744 , 3744 | -- | 2637 | -- | ||
| 4 | (BS >= BSTbl[BSsize-1])=False and ( BSTbl[BSindex+1] < BS )=False | 3333 | 5455 | 3 | 3 | 2222 , 4633 ,4633 | 42769 , 42769 ,42769 | 4232, 4232 ,4232 | 2521 , 2521 ,2521 | 2637, 2637 ,2637 | -- | 4232 | -- | ||
| 5 | ((BSTbl[BSindex] == BSTbl[BSindex+1] =False&& (BSindex > 0))) | 65530 | 8678 | 3 | 3 | 26327 , 26327 ,1234 | 4633 , 4633 ,4633 | 2637, 2637 ,2637 | 4232, 4232 ,4232 | 2521 , 2521 ,2521 | -- | 4232 | -- | ||
| 6 | ( BSTbl[BSindex+1] < BS )=True | 3333 | 5455 | 3 | 3 | 2222 , 2222 ,4633 | 42769 , 42769 ,42769 | 4232, 4232 ,4232 | 2521 , 2521 ,2521 | 2637, 2637 ,2637 | -- | 2521 | -- | ||
| 7 | (input >= XTbl[Xsize-1])=False and ( XTbl[Xindex+1] < input )=False | 5645 | 800 | 3 | 3 | 4444 , 4444 ,4444 | 500, 1000 ,1000 | 2637, 2637 ,2637 | 8546, 8546 ,8546 | 3744, 3744 , 3744 | -- | 2637 | -- | ||
| 8 | ( XTbl[Xindex+1] < input )=True | 5645 | 800 | 3 | 3 | 4444 , 4444 ,4444 | 500, 500 ,1000 | 2637, 2637 ,2637 | 8546, 8546 ,8546 | 3744, 3744 , 3744 | -- | 2637 | -- | ||
| 9 | ((sint32)Denominator_f32 == 0)=False | 0 | 7980 | 3 | 3 | 2220 ,2222 ,2222 | 37380 , 37382 , 37382 | 2521 , 2521 ,2521 | 4232, 4232 ,4232 | 12345, 12345 , 12345 | -- | 2521 | -- | ||
Sheet 9: BilinearXYM_u16_u16Xu16YM_Cnt B
| BilinearXYM_u16_u16Xu16YM_Cnt | TS | -- | |||||||||||||
| B | Param1 | Param2 | Param3 | Param4 | I/P5 | I/P6 | I/P7 | I/P8 | I/P9 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | BS2 | input2 | BSsize2 | Xsize2 | 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] | BilinearXYM_u16_u16Xu16YM_Cnt | BilinearXYM_u16_u16Xu16YM_Cnt | P/F | CPU Cycles | |
| 1 | param 1 min | 0 | 7980 | 3 | 3 | 2222 ,2222 ,2222 | 37382 , 37382 , 37382 | 2521 , 2521 ,2521 | 4232, 4232 ,4232 | 12345, 12345 , 12345 | -- | 2521 | -- | ||
| 2 | param 1 max | 65535 | 5455 | 3 | 3 | 4633 , 4633 ,4633 | 42769 , 42769 ,42769 | 4232, 4232 ,4232 | 2521 , 2521 ,2521 | 2637, 2637 ,2637 | -- | 4232 | -- | ||
| 3 | param 1 pos | 12345 | 3123 | 3 | 3 | 6478 , 6478 ,6478 | 52636 , 52636 ,52636 | 2521 , 2521 ,2521 | 1312 , 1312 ,1312 | 8546, 8546 ,8546 | -- | 2521 | -- | ||
| 4 | param 2 min | 2342 | 0 | 3 | 3 | 3333 , 3333 ,3333 | 5555 , 5555 ,5555 | 1312 , 1312 ,1312 | 2637, 2637 ,2637 | 9484, 9484 ,9484 | -- | 1312 | -- | ||
| 5 | param 2 max | 5645 | 65535 | 3 | 3 | 4444 , 4444 ,4444 | 1000, 1000 ,1000 | 2637, 2637 ,2637 | 8546, 8546 ,8546 | 3744, 3744 , 3744 | -- | 2637 | -- | ||
| 6 | param 2 pos | 4232 | 4357 | 3 | 3 | 5555 , 5555 ,5555 | 1432 , 1432, 1432 | 8546, 8546 ,8546 | 9484, 9484 ,9484 | 17633, 17633 ,17633 | -- | 8546 | -- | ||
| 7 | param 3 default | 1111 | 6784 | 3 | 3 | 3637 , 3637 ,3637 | 2525, 2525, 2525 | 9484, 9484 ,9484 | 3744, 3744 ,3744 | 26385, 26385 ,26384 | -- | 9484 | -- | ||
| 8 | param 4 default | 2222 | 5467 | 3 | 3 | 2754 , 2754 ,2754 | 1122, 1122, 1122 | 3744, 3744 ,3744 | 17633, 17633 ,17633 | 7236, 7236 ,7236 | -- | 3744 | -- | ||
| 9 | I/p 5 min | 3333 | 3536 | 3 | 3 | 0, 0 ,0 | 4633 , 4633 ,4633 | 17633, 17633 ,17633 | 26385, 26385 ,26385 | 5820, 5820 ,5820 | -- | 17633 | -- | ||
| 10 | I/p 5 max | 4444 | 9789 | 3 | 3 | 65535 ,65535 ,65535 | 6478 , 6478 ,6478 | 26385, 26385 ,26385 | 7236, 7236 ,7236 | 17552, 17552 ,17552 | -- | 26385 | -- | ||
| 11 | I/p 5 pos | 5555 | 4234 | 3 | 3 | 2754 , 2754 ,2754 | 3333 , 3333 ,3333 | 7236, 7236 ,7236 | 5820, 5820 ,5820 | 27544, 27544 ,27544 | -- | 7236 | -- | ||
| 12 | I/p 6 min | 6666 | 7889 | 3 | 3 | 37382 , 37382 , 37382 | 0, 0 ,0 | 5820, 5820 ,5820 | 17552, 17552 ,17552 | 6439, 6439 ,6439 | -- | 5820 | -- | ||
| 13 | I/p 6 max | 7777 | 4234 | 3 | 3 | 42769 , 42769 ,42769 | 65535 ,65535 ,65535 | 17552, 17552 ,17552 | 27544, 27544 ,27544 | 6459, 6459 ,6459 | -- | 17552 | -- | ||
| 14 | I/p 6 pos | 8888 | 7656 | 3 | 3 | 52636 , 52636 ,52636 | 5555 , 5555 ,5555 | 27544, 27544 ,27544 | 6439, 6439 ,6439 | 4232, 4232 ,4232 | -- | 27544 | -- | ||
| 15 | I/p 7 min | 9999 | 8073 | 3 | 3 | 5555 , 5555 ,5555 | 4444 , 4444 ,4444 | 0, 0 ,0 | 6459, 6459 ,6459 | 6439, 6439 ,6439 | -- | 0 | -- | ||
| 16 | I/p 7 max | 6434 | 2436 | 3 | 3 | 1000, 1000 ,1000 | 5555 , 5555 ,5555 | 65535 ,65535 ,65535 | 4232, 4232 ,4232 | 6459, 6459 ,6459 | -- | 65535 | -- | ||
| 17 | I/p 7 pos | 8564 | 8674 | 3 | 3 | 1432 , 1432, 1432 | 3637 , 3637 ,3637 | 5820, 5820 ,5820 | 2521 , 2521 ,2521 | 4232, 4232 ,4232 | -- | 5820 | -- | ||
| 18 | All min | 0 | 0 | 3 | 3 | 0, 0 ,0 | 0, 0 ,0 | 0, 0 ,0 | 0, 0 ,0 | 0, 0 ,0 | -- | 0 | -- | ||
| 19 | All max | 65535 | 65535 | 3 | 3 | 65535 ,65535 ,65535 | 65535 ,65535 ,65535 | 65535 ,65535 ,65535 | 65535 ,65535 ,65535 | 65535 ,65535 ,65535 | -- | 65535 | -- | ||
Sheet 10: BilinearXMYM_u16_u16XMu16YM_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| BilinearXMYM_u16_u16XMu16YM_Cnt | B | 19 | BilinearXMYM_u16_u16XMu16YM_Cnt_BSTbl[3] | ||
| BilinearXMYM_u16_u16XMu16YM_Cnt | P | 10 | 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] | |||||
Sheet 11: BilinearXMYM_u16_u16XMu16YM_C P
| BilinearXMYM_u16_u16XMu16YM_Cnt | TS | -- | |||||||||||||||
| P | Param1 | Param2 | Param3 | Param4 | I/P5 | I/P6 | I/P7 | I/P8 | I/P9 | I/P10 | I/P11 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | BS3 | input3 | BSsize3 | Xsize3 | 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_u16_u16XMu16YM_Cnt | BilinearXMYM_u16_u16XMu16YM_Cnt | P/F | CPU Cycles | |
| 1 | (BS <= BSTbl[0])=True and (input <= XMTbl[BSindex*Xsize])=False and (input >= XMTbl[(BSindex*Xsize)+Xsize-1])=True and ((XMTbl[(BSindex*Xsize)+X1index] == XMTbl[(BSindex*Xsize)+X1index+1])=False && (X1index > 0)) and (input2 <= XMTbl[(BSindex+1)*Xsize])=false and (input2 >= XMTbl[((BSindex+1)*Xsize)+Xsize-1])=True and ((XMTbl[((BSindex+1)*Xsize)+X2index] == XMTbl[((BSindex+1)*Xsize)+X2index+1]) =false&& (X2index > 0)) and ((sint32)Denominator_f32 == 0)=False | 0 | 9054 | 3 | 3 | 2563 , 4739 , 6960 | 1628 , 4628 , 3537 | 2648 , 6895 , 2893 | 2839 , 5894 , 2920 | 3849 , 6960 , 2372 | 2728 , 5859 , 2738 | 6278 , 4849 , 6960 | -- | 2372 | -- | ||
| 2 | (BS <= BSTbl[0])=False and (BS >= BSTbl[BSsize-1])=True and (BSTbl[BSindex] == BSTbl[BSindex+1]=False && (BSindex > 0)) and (input >= XMTbl[(BSindex*Xsize)+Xsize-1])=False and ( XMTbl[(BSindex*Xsize)+X1index+1] < input )=False and (input2 <= XMTbl[(BSindex+1)*Xsize])=True | 65535 | 3534 | 3 | 3 | 2685 , 5689 , 6890 | 2764 , 4739 , 4894 | 1628 , 4628 , 3537 | 3849 , 6960 , 2372 | 1628 , 4628 , 3537 | 2648 , 6895 , 2893 | 2522 , 6960 , 26238 | -- | 2522 | -- | ||
| 3 | (input <= XMTbl[BSindex*Xsize])=True | 6456 | 0 | 3 | 3 | 3829 , 6893 , 2303 | 4527 , 6869 , 3638 | 6448 , 2376 , 6960 | 2764 , 4739 , 4894 | 6448 , 2376 , 6960 | 2764 , 4739 , 4894 | 2839 , 5894 , 2920 | -- | 2839 | -- | ||
| 4 | ( XMTbl[(BSindex*Xsize)+X1index+1] < input )=True | 35476 | 5343 | 3 | 3 | 8660 , 6950 , 3638 | 2685 , 5689 , 6890 | 2563 , 4739 , 6960 | 2638 , 3628 , 3782 | 2563 , 4739 , 6960 | 2638 , 3628 , 3782 | 6448 , 2376 , 6960 | -- | 6960 | -- | ||
| 5 | (BSTbl[BSindex] == BSTbl[BSindex+1] =True && (BSindex > 0))=True and (BSTbl[BSindex] == BSTbl[BSindex+1] =True&& (BSindex > 0))=False and ((sint32)Denominator_f32 == 0)=true | 46432 | 6896 | 3 | 3 | 0,0,0 | 4173 , 4580 , 4890 | 2685 , 5689 , 6890 | 2563 , 4739 , 6960 | 2685 , 5689 , 6890 | 2563 , 4739 , 6960 | 4527 , 6869 , 3638 | -- | 5689 | -- | ||
| 6 | (BS >= BSTbl[BSsize-1])=False and ( BSTbl[BSindex+1] < BS )=False and ((XMTbl[(BSindex*Xsize)+X1index] == XMTbl[(BSindex*Xsize)+X1index+1])=True && (X1index > 0))=True and ((XMTbl[(BSindex*Xsize)+X1index] == XMTbl[(BSindex*Xsize)+X1index+1])=True && (X1index > 0))=False | 2534 | 3335 | 3 | 3 | 1628 , 4628 , 3537 | 0,0,0 | 7850 , 2783 , 5905 | 3829 , 6893 , 2303 | 7850 , 2783 , 5905 | 3829 , 6893 , 2303 | 2563 , 4739 , 6960 | -- | 7850 | -- | ||
| 7 | ( BSTbl[BSindex+1] < BS )=True | 2534 | 3335 | 3 | 3 | 1628 , 2000 , 3537 | 0,0,0 | 7850 , 2783 , 5905 | 3829 , 6893 , 2303 | 7850 , 2783 , 5905 | 3829 , 6893 , 2303 | 2563 , 4739 , 6960 | -- | 3389 | -- | ||
| 8 | (input2 >= XMTbl[((BSindex+1)*Xsize)+Xsize-1])=false and ( XMTbl[((BSindex+1)*Xsize)+X2index+1] < input )=False | 0 | 9054 | 3 | 3 | 2563 , 4739 , 6960 | 1628 , 4628 , 3537 | 2648 , 6895 , 10000 | 2839 , 5894 , 2920 | 3849 , 6960 , 2372 | 2728 , 5859 , 2738 | 6278 , 4849 , 6960 | -- | 2372 | -- | ||
| 9 | ((XMTbl[((BSindex+1)*Xsize)+X2index] == XMTbl[((BSindex+1)*Xsize)+X2index+1])=True && (X2index > 0))=True and ((XMTbl[((BSindex+1)*Xsize)+X2index] == XMTbl[((BSindex+1)*Xsize)+X2index+1]) =True && (X2index > 0))=false | 0 | 9054 | 3 | 3 | 2563 , 4739 , 6960 | 1628 , 4628 , 3537 | 6895 , 6895 , 6895 | 2839 , 5894 , 2920 | 3849 , 6960 , 2372 | 2728 , 5859 , 2738 | 6278 , 4849 , 6960 | -- | 6960 | -- | ||
| 10 | ( XMTbl[((BSindex+1)*Xsize)+X2index+1] < input )=True | 0 | 9054 | 3 | 3 | 2563 , 4739 , 6960 | 1628 , 4628 , 6900 | 2648 , 6895 , 10000 | 2839 , 5894 , 2920 | 3849 , 6960 , 2372 | 2728 , 5859 , 2738 | 6278 , 4849 , 6960 | -- | 2372 | -- | ||
Sheet 12: BilinearXMYM_u16_u16XMu16YM_C B
| BilinearXMYM_u16_u16XMu16YM_Cnt | TS | -- | |||||||||||||||
| B | Param1 | Param2 | Param3 | Param4 | I/P5 | I/P6 | I/P7 | I/P8 | I/P9 | I/P10 | I/P11 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | BS3 | input3 | BSsize3 | Xsize3 | 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_u16_u16XMu16YM_Cnt | BilinearXMYM_u16_u16XMu16YM_Cnt | P/F | CPU Cycles | |
| 1 | param 1 min | 0 | 9054 | 3 | 3 | 2563 , 4739 , 6960 | 1628 , 4628 , 3537 | 2648 , 6895 , 2893 | 2839 , 5894 , 2920 | 3849 , 6960 , 2372 | 2728 , 5859 , 2738 | 6278 , 4849 , 6960 | -- | 2372 | -- | ||
| 2 | param 1 max | 65535 | 3534 | 3 | 3 | 2685 , 5689 , 6890 | 2764 , 4739 , 4894 | 1628 , 4628 , 3537 | 3849 , 6960 , 2372 | 1628 , 4628 , 3537 | 2648 , 6895 , 2893 | 2522 , 6960 , 26238 | -- | 2522 | -- | ||
| 3 | param 1 pos | 6562 | 8064 | 3 | 3 | 4173 , 4580 , 4890 | 6448 , 2376 , 6960 | 2764 , 4739 , 4894 | 1628 , 4628 , 3537 | 2764 , 4739 , 4894 | 1628 , 4628 , 3537 | 12637 , 4748 , 5850 | -- | 5850 | -- | ||
| 4 | param 2 min | 6456 | 0 | 3 | 3 | 3829 , 6893 , 2303 | 4527 , 6869 , 3638 | 6448 , 2376 , 6960 | 2764 , 4739 , 4894 | 6448 , 2376 , 6960 | 2764 , 4739 , 4894 | 2839 , 5894 , 2920 | -- | 2839 | -- | ||
| 5 | param 2 max | 5733 | 65535 | 3 | 3 | 7850 , 2783 , 5905 | 1528 , 3628 , 2820 | 4527 , 6869 , 3638 | 6448 , 2376 , 6960 | 4527 , 6869 , 3638 | 6448 , 2376 , 6960 | 3849 , 6960 , 2372 | -- | 3638 | -- | ||
| 6 | param 2 pos | 7964 | 8087 | 3 | 3 | 1839 , 2789 , 4840 | 2638 , 3628 , 3782 | 1528 , 3628 , 2820 | 4527 , 6869 , 3638 | 1528 , 3628 , 2820 | 4527 , 6869 , 3638 | 1628 , 4628 , 3537 | -- | 3537 | -- | ||
| 7 | param 3 deafult | 2533 | 6978 | 3 | 3 | 3895 , 6899 , 5905 | 2563 , 4739 , 6960 | 2638 , 3628 , 3782 | 1528 , 3628 , 2820 | 2638 , 3628 , 3782 | 1528 , 3628 , 2820 | 2764 , 4739 , 4894 | -- | 3782 | -- | ||
| 8 | param 4 default | 35476 | 5343 | 3 | 3 | 8660 , 6950 , 3638 | 2685 , 5689 , 6890 | 2563 , 4739 , 6960 | 2638 , 3628 , 3782 | 2563 , 4739 , 6960 | 2638 , 3628 , 3782 | 6448 , 2376 , 6960 | -- | 6960 | -- | ||
| 9 | I/p 5 min | 46432 | 6896 | 3 | 3 | 0,0,0 | 4173 , 4580 , 4890 | 2685 , 5689 , 6890 | 2563 , 4739 , 6960 | 2685 , 5689 , 6890 | 2563 , 4739 , 6960 | 4527 , 6869 , 3638 | -- | 5689 | -- | ||
| 10 | I/p 5 max | 53543 | 1234 | 3 | 3 | 65535 , 65535, 65535 | 3829 , 6893 , 2303 | 4173 , 4580 , 4890 | 2685 , 5689 , 6890 | 4173 , 4580 , 4890 | 2685 , 5689 , 6890 | 1528 , 3628 , 2820 | -- | 4173 | -- | ||
| 11 | I/p 5 pos | 61456 | 2534 | 3 | 3 | 1234 , 2345 , 3456 | 7850 , 2783 , 5905 | 3829 , 6893 , 2303 | 4173 , 4580 , 4890 | 3829 , 6893 , 2303 | 4173 , 4580 , 4890 | 2638 , 3628 , 3782 | -- | 2638 | -- | ||
| 12 | I/p 6 min | 2534 | 3335 | 3 | 3 | 1628 , 4628 , 3537 | 0,0,0 | 7850 , 2783 , 5905 | 3829 , 6893 , 2303 | 7850 , 2783 , 5905 | 3829 , 6893 , 2303 | 2563 , 4739 , 6960 | -- | 7850 | -- | ||
| 13 | I/p 6 max | 6433 | 4647 | 3 | 3 | 2764 , 4739 , 4894 | 65535 , 65535, 65535 | 1839 , 2789 , 4840 | 7850 , 2783 , 5905 | 1839 , 2789 , 4840 | 7850 , 2783 , 5905 | 2685 , 5689 , 6890 | -- | 2685 | -- | ||
| 14 | I/p 6 pos | 8654 | 5785 | 3 | 3 | 6448 , 2376 , 6960 | 1111 , 2222 , 3333 | 3895 , 6899 , 5905 | 1839 , 2789 , 4840 | 3895 , 6899 , 5905 | 1839 , 2789 , 4840 | 4173 , 4580 , 4890 | -- | 4890 | -- | ||
| 15 | I/p 9 min | 3645 | 6633 | 3 | 3 | 4527 , 6869 , 3638 | 1839 , 2789 , 4840 | 8660 , 6950 , 3638 | 3895 , 6899 , 5905 | 0,0,0 | 3895 , 6899 , 5905 | 3829 , 6893 , 2303 | -- | 0 | -- | ||
| 16 | I/p 9 max | 8707 | 7532 | 3 | 3 | 1528 , 3628 , 2820 | 3895 , 6899 , 5905 | 6383 , 5690 , 2839 | 8660 , 6950 , 3638 | 65535 , 65535, 65535 | 8660 , 6950 , 3638 | 6484 , 2639 , 4849 | -- | 6484 | -- | ||
| 17 | I/p 9 pos | 4745 | 8573 | 3 | 3 | 2638 , 3628 , 3782 | 8660 , 6950 , 3638 | 6585 , 1920 , 5850 | 4683 , 2829 , 5895 | 4567 , 5678 , 6783 | 6383 , 5690 , 2839 | 32648 , 7494 , 2829 | -- | 2829 | -- | ||
| 18 | All min | 0 | 0 | 3 | 3 | 0,0,0 | 0,0,0 | 0,0,0 | 0,0,0 | 0,0,0 | 0,0,0 | 0,0,0 | -- | 0 | -- | ||
| 19 | All max | 65535 | 65535 | 3 | 3 | 65535 , 65535, 65535 | 65535 , 65535, 65535 | 65535 , 65535, 65535 | 65535 , 65535, 65535 | 65535 , 65535, 65535 | 65535 , 65535, 65535 | 65535 , 65535, 65535 | -- | 65535 | -- | ||
Sheet 13: BilinearXMYM_s16_u16XMs16YM_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| BilinearXMYM_s16_u16XMs16YM_Cnt | B | 21 | BilinearXMYM_s16_u16XMs16YM_Cnt_BSTbl[3] | ||
| BilinearXMYM_s16_u16XMs16YM_Cnt | P | 11 | 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] | |||||
Sheet 14: BilinearXMYM_s16_u16XMs16YM_C P
| BilinearXMYM_s16_u16XMs16YM_Cnt | TS | -- | |||||||||||||||
| P | Param | Param | Param | Param | I/P5 | I/P6 | I/P7 | I/P8 | I/P9 | I/P10 | I/P11 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | BS4 | input4 | BSsize4 | Xsize4 | 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_u16XMs16YM_Cnt | BilinearXMYM_s16_u16XMs16YM_Cnt | P/F | CPU Cycles | |
| 1 | (BS <= BSTbl[0])=True and (input <= XMTbl[BSindex*Xsize])=True and (input2 <= XMTbl[(BSindex+1)*Xsize])=True and ((sint32)Denominator_f32 == 0)=True and (Output_f32>=0)=False | 0 | 1231 | 3 | 3 | 2563 , 4739 , 6960 | 4444 , 4444 ,4444 | 3333 , 3333 ,3333 | 1628 , 2839 , 3839 | -6459, -6459 ,-6459 | 4683 , 5894 , 2829 | 2627 , 8942 , 2782 | -- | -6459 | -- | ||
| 2 | (BS <= BSTbl[0])=False and (BS >= BSTbl[BSsize-1])=True and (BSTbl[BSindex] == BSTbl[BSindex+1] =False&& (BSindex > 0)) and (input <= XMTbl[BSindex*Xsize])=False and (input >= XMTbl[(BSindex*Xsize)+Xsize-1])=True and ((XMTbl[(BSindex*Xsize)+X1index] == XMTbl[(BSindex*Xsize)+X1index+1]) =False&& (X1index > 0)) and ((sint32)Denominator_f32 == 0)=False | 65535 | 4342 | 3 | 3 | 2685 , 5689 , 6890 | 5555 , 5555 ,5555 | 3422 , 4728 , 1272 | 8494 , 2782 , 5894 | 4232, 4232 ,4232 | 4232, 4232 ,4232 | -6282 , -2892 , -2829 | -- | -6282 | -- | ||
| 3 | ((XMTbl[(BSindex*Xsize)+X1index] == XMTbl[(BSindex*Xsize)+X1index+1]) =True && (X1index > 0))=True and ((XMTbl[(BSindex*Xsize)+X1index] == XMTbl[(BSindex*Xsize)+X1index+1])=True && (X1index > 0))=False and (input2 <= XMTbl[(BSindex+1)*Xsize])=False and (input2 >= XMTbl[((BSindex+1)*Xsize)+Xsize-1])=True and ((XMTbl[((BSindex+1)*Xsize)+X2index] == XMTbl[((BSindex+1)*Xsize)+X2index+1]) =False && (X2index > 0)) | 321 | 65535 | 3 | 3 | 7850 , 2783 , 5905 | 5555 , 5555 ,5555 | 5262 , 7283 , 8950 | 1629 , 7849 , 3840 | -2637, -2637 ,-2637 | -2637, -2637 ,-2637 | 8546, 8546 ,8546 | -- | -2637 | -- | ||
| 4 | (BS >= BSTbl[BSsize-1])=False and ( BSTbl[BSindex+1] < BS )=False | 4234 | 8769 | 3 | 3 | 3895 , 6899 , 5905 | 1432 , 1432, 1432 | 1628 , 2839 , 3839 | 2738 , 6956 , 2784 | -9484, -9484 ,-9484 | -9484, -9484 ,-9484 | -3744, -3744 , -3744 | -- | -9484 | -- | ||
| 5 | (BSTbl[BSindex] == BSTbl[BSindex+1]=True && (BSindex > 0))=True and (BSTbl[BSindex] == BSTbl[BSindex+1] =True&& (BSindex > 0))=False and (Output_f32>=0)=True | 4234 | 2266 | 3 | 3 | 0 , 0, 0 | 1122, 1122, 1122 | 9505 , 6950 , 3739 | 2733 , 5990 , 2839 | 17633, 17633 ,17633 | 17633, 17633 ,17633 | 26385, 26385 ,26384 | -- | 17633 | -- | ||
| 6 | ( BSTbl[BSindex+1] < BS )=True | 3123 | 7567 | 3 | 3 | 1111 , 2222 , 3333 | 6478 , 6478 ,6478 | 1629 , 7849 , 3840 | 8934 , 4984 , 2849 | -7236, -7236 ,-7236 | -7236, -7236 ,-7236 | 5820, 5820 ,5820 | -- | 3352 | -- | ||
| 7 | (input >= XMTbl[(BSindex*Xsize)+Xsize-1])=False and ( XMTbl[(BSindex*Xsize)+X1index+1] < input )=False | 65535 | 4342 | 3 | 3 | 2685 , 5689 , 6890 | 5555 , 5555 ,5555 | 3422 , 4728 , 5000 | 8494 , 2782 , 5894 | 4232, 4232 ,4232 | 4232, 4232 ,4232 | -6282 , -2892 , -2829 | -- | -6282 | -- | ||
| 8 | ( XMTbl[(BSindex*Xsize)+X1index+1] < input )=True | 65535 | 4342 | 3 | 3 | 2685 , 5689 , 6890 | 5555 , 5555 ,5555 | 3422 , 4000 , 5000 | 8494 , 2782 , 5894 | 4232, 4232 ,4232 | 4232, 4232 ,4232 | -6282 , -2892 , -2829 | -- | -6282 | -- | ||
| 9 | (input2 >= XMTbl[((BSindex+1)*Xsize)+Xsize-1])=False and ( XMTbl[((BSindex+1)*Xsize)+X2index+1] < input )=False | 321 | 1500 | 3 | 3 | 7850 , 2783 , 5905 | 5555 , 5555 ,5555 | 1000 , 7283 , 2000 | 1629 , 7849 , 3840 | -2637, -2637 ,-2637 | -2637, -2637 ,-2637 | 8546, 8546 ,8546 | -- | -2637 | -- | ||
| 10 | ((XMTbl[((BSindex+1)*Xsize)+X2index] == XMTbl[((BSindex+1)*Xsize)+X2index+1]) =True && (X2index > 0))=true and ((XMTbl[((BSindex+1)*Xsize)+X2index] == XMTbl[((BSindex+1)*Xsize)+X2index+1])=True && (X2index > 0))=False | 321 | 65535 | 3 | 3 | 7850 , 2783 , 5905 | 5555 , 5555 ,5555 | 7283 , 7283 , 7283 | 1629 , 7849 , 3840 | -2637, -2637 ,-2637 | -2637, -2637 ,-2637 | 8546, 8546 ,8546 | -- | -2637 | -- | ||
| 11 | ( XMTbl[((BSindex+1)*Xsize)+X2index+1] < input )=True | 321 | 1500 | 3 | 3 | 7850 , 2783 , 5905 | 5555 , 5555 ,5555 | 1000 , 5000 , 2000 | 1629 , 7849 , 3840 | -2637, -2637 ,-2637 | -2637, -2637 ,-2637 | 8546, 8546 ,8546 | -- | -2637 | -- | ||
Sheet 15: BilinearXMYM_s16_u16XMs16YM_C B
| BilinearXMYM_s16_u16XMs16YM_Cnt | TS | -- | |||||||||||||||
| B | Param | Param | Param | Param | I/P5 | I/P6 | I/P7 | I/P8 | I/P9 | I/P10 | I/P11 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | BS4 | input4 | BSsize4 | Xsize4 | 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_u16XMs16YM_Cnt | BilinearXMYM_s16_u16XMs16YM_Cnt | P/F | CPU Cycles | |
| 1 | param 1 min | 0 | 1231 | 3 | 3 | 2563 , 4739 , 6960 | 4444 , 4444 ,4444 | 3333 , 3333 ,3333 | 1628 , 2839 , 3839 | -6459, -6459 ,-6459 | 4683 , 5894 , 2829 | 2627 , 8942 , 2782 | -- | -6459 | -- | ||
| 2 | param 1 max | 65535 | 4342 | 3 | 3 | 2685 , 5689 , 6890 | 5555 , 5555 ,5555 | 3422 , 4728 , 1272 | 8494 , 2782 , 5894 | 4232, 4232 ,4232 | 4232, 4232 ,4232 | -6282 , -2892 , -2829 | -- | -6282 | -- | ||
| 3 | param 1 pos | 5525 | 7885 | 3 | 3 | 4173 , 4580 , 4890 | 3637 , 3637 ,3637 | 6890 , 2839 , 6895 | 9505 , 6950 , 3739 | 2521 , 2521 ,2521 | 2521 , 2521 ,2521 | -12345, -12345 , -12345 | -- | -12345 | -- | ||
| 4 | param 2 min | 4244 | 0 | 3 | 3 | 3829 , 6893 , 2303 | 52636 , 52636 ,52636 | 5172 , 5899 , 1783 | 6749 , 2839 , 7849 | 1312 , 1312 ,1312 | 1312 , 1312 ,1312 | -2637, -2637 ,-2637 | -- | -2637 | -- | ||
| 5 | param 2 max | 321 | 65535 | 3 | 3 | 7850 , 2783 , 5905 | 5555 , 5555 ,5555 | 5262 , 7283 , 8950 | 1629 , 7849 , 3840 | -2637, -2637 ,-2637 | -2637, -2637 ,-2637 | 8546, 8546 ,8546 | -- | -2637 | -- | ||
| 6 | param 2 pos | 7567 | 4233 | 3 | 3 | 1839 , 2789 , 4840 | 1000, 1000 ,1000 | 4234 , 3783 , 2628 | 8590 , 2834 , 6950 | 8546, 8546 ,8546 | 8546, 8546 ,8546 | -9484, -9484 ,-9484 | -- | -9484 | -- | ||
| 7 | param 3 default | 4234 | 8769 | 3 | 3 | 3895 , 6899 , 5905 | 1432 , 1432, 1432 | 1628 , 2839 , 3839 | 2738 , 6956 , 2784 | -9484, -9484 ,-9484 | -9484, -9484 ,-9484 | -3744, -3744 , -3744 | -- | -9484 | -- | ||
| 8 | param 4 deafult | 787 | 4323 | 3 | 3 | 8660 , 6950 , 3638 | 2525, 2525, 2525 | 8494 , 2782 , 5894 | 8595 , 2849 , 6956 | -3744, -3744 ,-3744 | -3744, -3744 ,-3744 | 17633, 17633 ,17633 | -- | -3744 | -- | ||
| 9 | I/p 5 min | 4234 | 2266 | 3 | 3 | 0 , 0, 0 | 1122, 1122, 1122 | 9505 , 6950 , 3739 | 2733 , 5990 , 2839 | 17633, 17633 ,17633 | 17633, 17633 ,17633 | 26385, 26385 ,26384 | -- | 17633 | -- | ||
| 10 | I/p 5 max | 6456 | 2423 | 3 | 3 | 65535 , 65535 , 65535 | 4633 , 4633 ,4633 | 6749 , 2839 , 7849 | 9505 , 2849 , 6905 | 26385, 26385 ,26385 | 26385, 26385 ,26385 | -7236, -7236 ,-7236 | -- | 26385 | -- | ||
| 11 | I/p 5 pos | 3123 | 7567 | 3 | 3 | 1111 , 2222 , 3333 | 6478 , 6478 ,6478 | 1629 , 7849 , 3840 | 8934 , 4984 , 2849 | -7236, -7236 ,-7236 | -7236, -7236 ,-7236 | 5820, 5820 ,5820 | -- | 3352 | -- | ||
| 12 | I/p 6 min | 7897 | 8678 | 3 | 3 | 7432 , 7432 , 7432 | 0 , 0, 0 | 8590 , 2834 , 6950 | 2839 , 5895 ,2933 | 5820, 5820 ,5820 | 5820, 5820 ,5820 | 17552, 17552 ,17552 | -- | 5820 | -- | ||
| 13 | I/p 6 max | 5234 | 9087 | 3 | 3 | 26327 , 26327 ,26327 | 65535 , 65535 , 65535 | 2738 , 6956 , 2784 | 4849 , 128 , 2829 | 17552, 17552 ,17552 | 17552, 17552 ,17552 | 27544, 27544 ,27544 | -- | 17552 | -- | ||
| 14 | I/p 6 pos | 8979 | 423 | 3 | 3 | 37382 , 37382 , 37382 | 2345 , 3456 , 4567 | 8595 , 2849 , 6956 | 3333 , 3333 ,3333 | 27544, 27544 ,27544 | 27544, 27544 ,27544 | -6439, -6439 ,-6439 | -- | 27544 | -- | ||
| 15 | I/p 9 min | 5353 | 2522 | 3 | 3 | 42769 , 42769 ,42769 | 3333 , 3333 ,3333 | 2733 , 5990 , 2839 | 3422 , 4728 , 1272 | -32768 , -32768 , -32768 | -6439, -6439 ,-6439 | -6459, -6459 ,-6459 | -- | -32768 | -- | ||
| 16 | I/p 9 max | 9075 | 5222 | 3 | 3 | 52636 , 52636 ,52636 | 3422 , 4728 , 1272 | 9505 , 2849 , 6905 | 6890 , 2839 , 6895 | 32767 , 32767 , 32767 | -6459, -6459 ,-6459 | 4232, 4232 ,4232 | -- | 32767 | -- | ||
| 17 | I/p 9 zero | 4256 | 24523 | 3 | 3 | 5555 , 5555 ,5555 | 6890 , 2839 , 6895 | 8934 , 4984 , 2849 | 5172 , 5899 , 1783 | 0 , 0 , 0 | 4232, 4232 ,4232 | -6282 , -2627 , -2782 | -- | 0 | -- | ||
| 18 | I/p 9 neg | 4554 | 7564 | 3 | 3 | 3637 , 3637 ,3637 | 5172 , 5899 , 1783 | 2839 , 5895 ,2933 | 5262 , 7283 , 8950 | -1111 , -2222 , -3333 | 2521 , 2521 ,2521 | 7239 , 4893 , 1282 | -- | -2222 | -- | ||
| 19 | I/p 9 pos | 4128 | 4211 | 3 | 3 | 2754 , 2754 ,2754 | 5262 , 7283 , 8950 | 4849 , 128 , 2829 | 4234 , 3783 , 2628 | 2345 , 4567 , 5643 | 1312 , 1312 ,1312 | -7292 , -2789 , -2829 | -- | 2345 | -- | ||
| 20 | All min | 0 | 0 | 3 | 3 | 0 , 0, 0 | 0 , 0, 0 | 0 , 0, 0 | 0 , 0, 0 | -32768 , -32768 , -32768 | -32768 , -32768 , -32768 | -32768 , -32768 , -32768 | -- | -32768 | -- | ||
| 21 | All max | 65535 | 65535 | 3 | 3 | 65535 , 65535 , 65535 | 65535 , 65535 , 65535 | 65535 , 65535 , 65535 | 65535 , 65535 , 65535 | 32767 , 32767 , 32767 | 32767 , 32767 , 32767 | 32767 , 32767 , 32767 | -- | 32767 | -- | ||
Sheet 16: BilinearXMYM_s16_s16XMs16YM_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| BilinearXMYM_s16_s16XMs16YM_Cnt | B | 25 | BilinearXMYM_s16_s16XMs16YM_Cnt_BSTbl[3] | ||
| BilinearXMYM_s16_s16XMs16YM_Cnt | P | 9 | 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] | |||||
Sheet 17: BilinearXMYM_s16_s16XMs16YM_C P
| BilinearXMYM_s16_s16XMs16YM_Cnt | TS | -- | |||||||||||||||
| P | Param1 | Param2 | Param3 | Param4 | I/P5 | I/P6 | I/P7 | I/P8 | I/P9 | I/P10 | I/P11 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | BS5 | input5 | BSsize5 | Xsize5 | 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] | BilinearXMYM_s16_s16XMs16YM_Cnt | BilinearXMYM_s16_s16XMs16YM_Cnt | P/F | CPU Cycles | |
| 1 | (BS <= BSTbl[0])=True and (input <= XMTbl[BSindex*Xsize])=False and (input >= XMTbl[(BSindex*Xsize)+Xsize-1])=True and ((XMTbl[(BSindex*Xsize)+X1index] == XMTbl[(BSindex*Xsize)+X1index+1]) =True && (X1index > 0))=True and ((XMTbl[(BSindex*Xsize)+X1index] == XMTbl[(BSindex*Xsize)+X1index+1]) =True && (X1index > 0))=False and (input2 <= XMTbl[(BSindex+1)*Xsize])=False and (input2 >= XMTbl[((BSindex+1)*Xsize)+Xsize-1])=True and ((XMTbl[((BSindex+1)*Xsize)+X2index] == XMTbl[((BSindex+1)*Xsize)+X2index+1]) =False&& (X2index > 0)) and ((sint32)Denominator_f32 == 0)=True and (Output_f32>=0)=True | 0 | 2000 | 3 | 3 | 3441 , 5552 , 5252 | -12345, -12345 , -12345 | 1567 , 8922 , 1781 | -6292 , -1278 , -1681 | 562 , 7191 , 1781 | -618 , -178 , -729 | 5712 , 7189 , 1718 | -- | 562 | -- | ||
| 2 | (BS <= BSTbl[0])=False and (BS >= BSTbl[BSsize-1])=True and (BSTbl[BSindex] == BSTbl[BSindex+1]=False && (BSindex > 0)) and (input2 <= XMTbl[(BSindex+1)*Xsize])=True and (Output_f32>=0)=False | 65535 | -2000 | 3 | 3 | 6363 , 8349 , 3834 | -2637, -2637 ,-2637 | -6459, -6459 ,-6459 | -571 , -1781 , -1781 | 1567 , 8922 , 1781 | -6292 , -1278 , -1681 | -6188 , -1671 , -8292 | -- | -6292 | -- | ||
| 3 | (input <= XMTbl[BSindex*Xsize])=True | 1234 | 3000 | 3 | 3 | 6383 , 2782 , 282 | 8546, 8546 ,8546 | 4232, 4232 ,4232 | 4232, 4232 ,4232 | -6459, -6459 ,-6459 | -571 , -1781 , -1781 | 378 , 783 , 580 | -- | -6459 | -- | ||
| 4 | ((XMTbl[((BSindex+1)*Xsize)+X2index] == XMTbl[((BSindex+1)*Xsize)+X2index+1]) =True && (X2index > 0))=True and ((XMTbl[((BSindex+1)*Xsize)+X2index] == XMTbl[((BSindex+1)*Xsize)+X2index+1])=True && (X2index > 0))=False | 4234 | 32767 | 3 | 3 | 480 , 378 , 282 | -3744, -3744 , -3744 | 1312 , 1312 ,1312 | 1312 , 1312 ,1312 | 2521 , 2521 ,2521 | 2521 , 2521 ,2521 | -571 , -1781 , -1781 | -- | 2521 | -- | ||
| 5 | (BSTbl[BSindex] == BSTbl[BSindex+1]=True && (BSindex > 0))=True and (BSTbl[BSindex] == BSTbl[BSindex+1] =True && (BSindex > 0))=False | 5345 | -4000 | 3 | 3 | 0, 0 , 0 | 27544, 27544 ,27544 | 26385, 26385 ,26385 | 26385, 26385 ,26385 | 17633, 17633 ,17633 | 17633, 17633 ,17633 | -9484, -9484 ,-9484 | -- | 17633 | -- | ||
| 6 | (BS >= BSTbl[BSsize-1])=False and ( BSTbl[BSindex+1] < BS )=True and ( BSTbl[BSindex+1] < BS )=False | 4234 | -5000 | 3 | 3 | 2345 , 3456 , 4567 | -6459, -6459 ,-6459 | 5820, 5820 ,5820 | 5820, 5820 ,5820 | -7236, -7236 ,-7236 | -7236, -7236 ,-7236 | 17633, 17633 ,17633 | -- | -7236 | -- | ||
| 7 | ((XMTbl[(BSindex*Xsize)+X1index] == XMTbl[(BSindex*Xsize)+X1index+1]) =False&& (X1index > 0)) and ((sint32)Denominator_f32 == 0)=False | 4234 | 5228 | 3 | 3 | 7292 , 4279 , 2678 | -1581 , -2683 , -1270 | -6282 , -2782 , -2768 | 2628 , 1819 , 3782 | -2222 , -3333 , -4444 | -6459, -6459 ,-6459 | 2521 , 2521 ,2521 | -- | -4444 | -- | ||
| 8 | (input >= XMTbl[(BSindex*Xsize)+Xsize-1])=False and ( XMTbl[(BSindex*Xsize)+X1index+1] < input )=True and ( XMTbl[(BSindex*Xsize)+X1index+1] < input )=False and (input2 >= XMTbl[((BSindex+1)*Xsize)+Xsize-1])=False and ( XMTbl[((BSindex+1)*Xsize)+X2index+1] < input )=False | 0 | 2000 | 3 | 3 | 3441 , 5552 , 5252 | -12345, -12345 , 2100 | 1567 , 8922 , 1781 | -6292 , -1278 , -1681 | 562 , 7191 , 1781 | -618 , -178 , -729 | 5712 , 7189 , 1718 | -- | 1818 | -- | ||
| 9 | ( XMTbl[((BSindex+1)*Xsize)+X2index+1] < input )=True | 0 | 2000 | 3 | 3 | 3441 , 5552 , 5252 | -12345, -12345 , 2100 | 1567 , 1900 , 2100 | -6292 , -1278 , -1681 | 562 , 7191 , 1781 | -618 , -178 , -729 | 5712 , 7189 , 1718 | -- | 1818 | -- | ||
Sheet 18: BilinearXMYM_s16_s16XMs16YM_C B
| BilinearXMYM_s16_s16XMs16YM_Cnt | TS | -- | |||||||||||||||
| B | Param1 | Param2 | Param3 | Param4 | I/P5 | I/P6 | I/P7 | I/P8 | I/P9 | I/P10 | I/P11 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | BS5 | input5 | BSsize5 | Xsize5 | 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] | BilinearXMYM_s16_s16XMs16YM_Cnt | BilinearXMYM_s16_s16XMs16YM_Cnt | P/F | CPU Cycles | |
| 1 | param 1 min | 0 | 2000 | 3 | 3 | 3441 , 5552 , 5252 | -12345, -12345 , -12345 | 1567 , 8922 , 1781 | -6292 , -1278 , -1681 | 562 , 7191 , 1781 | -618 , -178 , -729 | 5712 , 7189 , 1718 | -- | 562 | -- | ||
| 2 | param 1 max | 65535 | -2000 | 3 | 3 | 6363 , 8349 , 3834 | -2637, -2637 ,-2637 | -6459, -6459 ,-6459 | -571 , -1781 , -1781 | 1567 , 8922 , 1781 | -6292 , -1278 , -1681 | -6188 , -1671 , -8292 | -- | -6292 | -- | ||
| 3 | param 1 pos | 1234 | 3000 | 3 | 3 | 6383 , 2782 , 282 | 8546, 8546 ,8546 | 4232, 4232 ,4232 | 4232, 4232 ,4232 | -6459, -6459 ,-6459 | -571 , -1781 , -1781 | 378 , 783 , 580 | -- | -6459 | -- | ||
| 4 | param 2 min | 6336 | -32768 | 3 | 3 | 4939 , 2782 , 1829 | -9484, -9484 ,-9484 | 2521 , 2521 ,2521 | 2521 , 2521 ,2521 | 4232, 4232 ,4232 | 4232, 4232 ,4232 | -6292 , -1278 , -1681 | -- | 4232 | -- | ||
| 5 | param 2 max | 4234 | 32767 | 3 | 3 | 480 , 378 , 282 | -3744, -3744 , -3744 | 1312 , 1312 ,1312 | 1312 , 1312 ,1312 | 2521 , 2521 ,2521 | 2521 , 2521 ,2521 | -571 , -1781 , -1781 | -- | 2521 | -- | ||
| 6 | param 2 zero | 7567 | 0 | 3 | 3 | 719 , 378 , 278 | 17633, 17633 ,17633 | -2637, -2637 ,-2637 | -2637, -2637 ,-2637 | 1312 , 1312 ,1312 | 1312 , 1312 ,1312 | 4232, 4232 ,4232 | -- | 1312 | -- | ||
| 7 | param 2 neg | 5234 | -1000 | 3 | 3 | 719 , 182 , 499 | 26385, 26385 ,26384 | 8546, 8546 ,8546 | 8546, 8546 ,8546 | -2637, -2637 ,-2637 | -2637, -2637 ,-2637 | 2521 , 2521 ,2521 | -- | -2637 | -- | ||
| 8 | param 2 pos | 8567 | 1000 | 3 | 3 | 571 , 2379 , 7892 | -7236, -7236 ,-7236 | -9484, -9484 ,-9484 | -9484, -9484 ,-9484 | 8546, 8546 ,8546 | 8546, 8546 ,8546 | 1312 , 1312 ,1312 | -- | 8546 | -- | ||
| 9 | param 3 default | 4234 | -2300 | 3 | 3 | 6128 , 1781 , 3789 | 5820, 5820 ,5820 | -3744, -3744 ,-3744 | -3744, -3744 ,-3744 | -9484, -9484 ,-9484 | -9484, -9484 ,-9484 | -2637, -2637 ,-2637 | -- | -9484 | -- | ||
| 10 | param 4 default | 6622 | 4000 | 3 | 3 | 2280 , 1729 , 3891 | 17552, 17552 ,17552 | 17633, 17633 ,17633 | 17633, 17633 ,17633 | -3744, -3744 ,-3744 | -3744, -3744 ,-3744 | 8546, 8546 ,8546 | -- | -3744 | -- | ||
| 11 | I/p 5 min | 5345 | -4000 | 3 | 3 | 0, 0 , 0 | 27544, 27544 ,27544 | 26385, 26385 ,26385 | 26385, 26385 ,26385 | 17633, 17633 ,17633 | 17633, 17633 ,17633 | -9484, -9484 ,-9484 | -- | 17633 | -- | ||
| 12 | I/p 5 max | 7567 | 5000 | 3 | 3 | 65535 , 65535 , 65535 | -6439, -6439 ,-6439 | -7236, -7236 ,-7236 | -7236, -7236 ,-7236 | 26385, 26385 ,26385 | 26385, 26385 ,26385 | -3744, -3744 ,-3744 | -- | 26385 | -- | ||
| 13 | I/p 5 pos | 4234 | -5000 | 3 | 3 | 2345 , 3456 , 4567 | -6459, -6459 ,-6459 | 5820, 5820 ,5820 | 5820, 5820 ,5820 | -7236, -7236 ,-7236 | -7236, -7236 ,-7236 | 17633, 17633 ,17633 | -- | -7236 | -- | ||
| 14 | I/p 6 min | 6756 | 6000 | 3 | 3 | 1512 , 3939 , 2923 | -32768 , -32768 , -32768 | 17552, 17552 ,17552 | 17552, 17552 ,17552 | 5820, 5820 ,5820 | 5820, 5820 ,5820 | 26385, 26385 ,26385 | -- | 5820 | -- | ||
| 15 | I/p 6 max | 5256 | -6000 | 3 | 3 | 7383 , 3930 , 2728 | 32767 , 32767 , 32767 | 27544, 27544 ,27544 | 27544, 27544 ,27544 | 17552, 17552 ,17552 | 17552, 17552 ,17552 | -7236, -7236 ,-7236 | -- | 17552 | -- | ||
| 16 | I/p 6 zero | 2412 | 7000 | 3 | 3 | 6383 , 2930 , 4904 | 0 , 0, 0 | -6439, -6439 ,-6439 | -6439, -6439 ,-6439 | 27544, 27544 ,27544 | 27544, 27544 ,27544 | 5820, 5820 ,5820 | -- | 27544 | -- | ||
| 17 | I/p 6 neg | 6789 | -7000 | 3 | 3 | 6289 , 9402 , 4789 | -2222 , -3333 , -4444 | -6459, -6459 ,-6459 | -6459, -6459 ,-6459 | -6439, -6439 ,-6439 | -6439, -6439 ,-6439 | 17552, 17552 ,17552 | -- | -6439 | -- | ||
| 18 | I/p 6 pos | 9086 | 8000 | 3 | 3 | 2799 , 4789, 3783 | 4839 , 3812 , 4894 | 4232, 4232 ,4232 | 4232, 4232 ,4232 | -6459, -6459 ,-6459 | -6459, -6459 ,-6459 | 27544, 27544 ,27544 | -- | -6459 | -- | ||
| 19 | I/p 9 min | 1242 | -8000 | 3 | 3 | 1638 , 3489 , 4789 | 6282 , 1782 , 3839 | 2521 , 2521 ,2521 | 2521 , 2521 ,2521 | -32768 , -32768 , -32768 | 4232, 4232 ,4232 | -6439, -6439 ,-6439 | -- | -32768 | -- | ||
| 20 | I/p 9 max | 6467 | 9000 | 3 | 3 | 1792 , 4893 , 27899 | -1581 , -1278 , -1781 | 1312 , 1312 ,1312 | 1312 , 1312 ,1312 | 32767 , 32767 , 32767 | 2521 , 2521 ,2521 | -6459, -6459 ,-6459 | -- | 2521 | -- | ||
| 21 | I/p 9 zero | 7809 | -9000 | 3 | 3 | 1638 , 7493 , 7849 | 5282 , 1819 , 3820 | 4232 , 729, 8292 | -6459, -6459 ,-6459 | 0 , 0, 0 | 1312 , 1312 ,1312 | 4232, 4232 ,4232 | -- | 1312 | -- | ||
| 22 | I/p 9 neg | 4234 | 5228 | 3 | 3 | 7292 , 4279 , 2678 | -1581 , -2683 , -1270 | -6282 , -2782 , -2768 | 2628 , 1819 , 3782 | -2222 , -3333 , -4444 | -6459, -6459 ,-6459 | 2521 , 2521 ,2521 | -- | -4444 | -- | ||
| 23 | I/p 9 pos | 3454 | -3478 | 3 | 3 | 4794 , 7830 , 2782 | 618 , 178 , 389 | 681 , 168 , 1891 | -1576 , -2782 , -1278 | 4839 , 3812 , 4894 | 2628 , 1819 , 3782 | -618 , -5618 , -1781 | -- | 4839 | -- | ||
| 24 | All min | 0 | -32768 | 3 | 3 | 0, 0 , 0 | -32768 , -32768 , -32768 | -32768 , -32768 , -32768 | -32768 , -32768 , -32768 | -32768 , -32768 , -32768 | -32768 , -32768 , -32768 | -32768 , -32768 , -32768 | -- | -32768 | -- | ||
| 25 | All max | 65535 | 32767 | 3 | 3 | 65535 , 65535 , 65535 | 32767 , 32767 , 32767 | 32767 , 32767 , 32767 | 32767 , 32767 , 32767 | 32767 , 32767 , 32767 | 32767 , 32767 , 32767 | 32767 , 32767 , 32767 | -- | 32767 | -- | ||
Sheet 19: IntplVarXY_u16_u16Xu16Y_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| IntplVarXY_u16_u16Xu16Y_Cnt | B | 12 | IntplVarXY_u16_u16Xu16Y_Cnt_TableX[4] | ||
| IntplVarXY_u16_u16Xu16Y_Cnt | P | 3 | IntplVarXY_u16_u16Xu16Y_Cnt_TableY[4] | ||
Sheet 20: IntplVarXY_u16_u16Xu16Y_Cnt() P
| IntplVarXY_u16_u16Xu16Y_Cnt | TS | -- | ||||||||
| P | Param1 | Param2 | I/P3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | Size6 | input6 | IntplVarXY_u16_u16Xu16Y_Cnt_TableX[4] | IntplVarXY_u16_u16Xu16Y_Cnt_TableY[4] | IntplVarXY_u16_u16Xu16Y_Cnt | IntplVarXY_u16_u16Xu16Y_Cnt | P/F | CPU Cycles | |
| 1 | ( input <= TableX[0] )=True | 4 | 53 | 6289 , 1801 , 3489 , 6383 | 6282 , 1829 , 8904 , 6171 | -- | 6282 | -- | ||
| 2 | ( input <= TableX[0] )=False and ( input >= TableX[Size-1] )=True | 4 | 65535 | 8393 , 1781 , 3479 , 8393 | 1839 , 4903 , 2789 ,3782 | -- | 3782 | -- | ||
| 3 | ( input >= TableX[Size-1] )=False and ( TableX[index+1] < input )=True and ( TableX[index+1] < input )=False and (diffX == 0)=False | 4 | 3000 | 2500 , 1781 , 3479 , 3500 | 1839 , 4903 , 2789 ,1811 | -- | 3386 | -- | ||
Sheet 21: IntplVarXY_u16_u16Xu16Y_Cnt() B
| IntplVarXY_u16_u16Xu16Y_Cnt | TS | -- | ||||||||
| B | Param1 | Param2 | I/P3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | Size6 | input6 | IntplVarXY_u16_u16Xu16Y_Cnt_TableX[4] | IntplVarXY_u16_u16Xu16Y_Cnt_TableY[4] | IntplVarXY_u16_u16Xu16Y_Cnt | IntplVarXY_u16_u16Xu16Y_Cnt | P/F | CPU Cycles | |
| 1 | param 1 default | 4 | 53 | 6289 , 1801 , 3489 , 6383 | 6282 , 1829 , 8904 , 6171 | -- | 6282 | -- | ||
| 2 | param 2 min | 4 | 0 | 2379 , 3789 , 2892 , 8390 | 7292 , 2380 , 2892 , 7111 | -- | 7292 | -- | ||
| 3 | param 2 max | 4 | 65535 | 8393 , 1781 , 3479 , 8393 | 1839 , 4903 , 2789 ,3782 | -- | 3782 | -- | ||
| 4 | param 2 pos | 4 | 1234 | 1738 , 805 , 12791 , 8933 | 4890 , 2892 , 3905 , 7128 | -- | 4890 | -- | ||
| 5 | I/p 3 min | 4 | 3424 | 0 , 0, 0 ,0 | 8022 , 2902 , 1289 ,1781 | -- | 1781 | -- | ||
| 6 | I/p 3 max | 4 | 4231 | 65535 , 65535 , 65535 ,65535 | 6283 , 1902 , 1890 , 8129 | -- | 6283 | -- | ||
| 7 | I/p 3 pos | 4 | 65 | 1111 , 2222, 3333 , 6289 | 7292 , 3890 , 2892 ,7282 | -- | 7292 | -- | ||
| 8 | I/p 4 min | 4 | 343 | 2345 , 56212 , 2782 , 7893 | 0 , 0, 0 ,0 | -- | 0 | -- | ||
| 9 | I/p 4 max | 4 | 8679 | 1671 , 3893 , 189 , 7822 | 65535 , 65535 , 65535 ,65535 | -- | 65535 | -- | ||
| 10 | I/p 4 pos | 4 | 2111 | 2682 , 1891 , 3893 , 7829 | 4444 , 5555, 6666 ,7829 | -- | 4444 | -- | ||
| 11 | All min | 4 | 0 | 0 , 0, 0 , 0 | 0 , 0, 0 , 0 | -- | 0 | -- | ||
| 12 | All max | 4 | 65535 | 65535 , 65535 , 65535 ,65535 | 65535 , 65535 , 65535 ,65535 | -- | 65535 | -- | ||
Sheet 22: IntplVarXY_u16_s16Xu16Y_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| IntplVarXY_u16_s16Xu16Y_Cnt | B | 16 | IntplVarXY_u16_s16Xu16Y_Cnt_TableX[3] | ||
| IntplVarXY_u16_s16Xu16Y_Cnt | P | 3 | IntplVarXY_u16_s16Xu16Y_Cnt_TableY[3] | ||
Sheet 23: IntplVarXY_u16_s16Xu16Y_Cnt() P
| IntplVarXY_u16_s16Xu16Y_Cnt | TS | -- | ||||||||
| P | Param1 | Param2 | I/P3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | Size7 | input7 | IntplVarXY_u16_s16Xu16Y_Cnt_TableX[3] | IntplVarXY_u16_s16Xu16Y_Cnt_TableY[3] | IntplVarXY_u16_s16Xu16Y_Cnt | IntplVarXY_u16_s16Xu16Y_Cnt | P/F | CPU Cycles | |
| 1 | ( input <= TableX[0] )=False and ( input >= TableX[Size-1] )=True | 3 | 443 | -6282 , -2920 , -5738 | 8900 , 6920 , 2682 | -- | 2682 | -- | ||
| 2 | ( input <= TableX[0] )=True | 3 | -32768 | 7393 , 6282 , 4894 | 3782 , 8923 , 1892 | -- | 3782 | -- | ||
| 3 | ( input >= TableX[Size-1] )=False and ( TableX[index+1] < input )=True and ( TableX[index+1] < input )=False and (diffX == 0)=False | 3 | 443 | -6282 , -2920 , 500 | 8900 , 6920 , 2682 | -- | 2753 | -- | ||
Sheet 24: IntplVarXY_u16_s16Xu16Y_Cnt() B
| IntplVarXY_u16_s16Xu16Y_Cnt | TS | -- | ||||||||
| B | Param1 | Param2 | I/P3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | Size7 | input7 | IntplVarXY_u16_s16Xu16Y_Cnt_TableX[3] | IntplVarXY_u16_s16Xu16Y_Cnt_TableY[3] | IntplVarXY_u16_s16Xu16Y_Cnt | IntplVarXY_u16_s16Xu16Y_Cnt | P/F | CPU Cycles | |
| 1 | param 1 default | 3 | 443 | -6282 , -2920 , -5738 | 8900 , 6920 , 2682 | -- | 2682 | -- | ||
| 2 | param 2 min | 3 | -32768 | 7393 , 6282 , 4894 | 3782 , 8923 , 1892 | -- | 3782 | -- | ||
| 3 | param 2 max | 3 | 32767 | -6489 , -2768 , -7589 | 3678 , 8303 , 2792 | -- | 2792 | -- | ||
| 4 | param 2 zero | 3 | 0 | 9373 , 2672 , 5789 | 4000 , 5000 , 6000 | -- | 4000 | -- | ||
| 5 | param 2 neg | 3 | -1234 | -7353 , -5839 , -1789 | 1000 , 2000 , 3000 | -- | 3000 | -- | ||
| 6 | param 2 pos | 3 | 234 | 6282 , 8494 , 2791 | 7894 , 6282 , 8022 | -- | 7894 | -- | ||
| 7 | I/p 3 min | 3 | -4332 | -32768 , -32768 , -32768 | 7289 , 9078 , 3782 | -- | 3782 | -- | ||
| 8 | I/p 3 max | 3 | 253 | 32767 , 32767 , 32767 | 1782 , 8393 , 8028 | -- | 1782 | -- | ||
| 9 | I/p 3 zero | 3 | -4562 | 0, 0, 0 | 5278 , 8940 , 2622 | -- | 5278 | -- | ||
| 10 | I/p 3 neg | 3 | 255 | -2345 , -5618 , -7891 | 2628 , 1829 , 8504 | -- | 8504 | -- | ||
| 11 | I/p 3 pos | 3 | -653 | 5278 , 1611 , 1789 | 7832 , 2628 , 8494 | -- | 7832 | -- | ||
| 12 | I/p 4 min | 3 | 3453 | 1267 , 2571 , 1791 | 0, 0, 0 | -- | 0 | -- | ||
| 13 | I/p 4 max | 3 | -653 | -1568 , -2629 , -3733 | 65535 , 65535 , 65535 | -- | 65535 | -- | ||
| 14 | I/p 4 pos | 3 | 2532 | 6393 , 3902 , 7383 | 1111 , 2222 , 3333 | -- | 1111 | -- | ||
| 15 | All min | 3 | -32768 | -32768 , -32768 , -32768 | 0, 0, 0 | -- | 0 | -- | ||
| 16 | All max | 3 | 32767 | 32767 , 32767 , 32767 | 65535 , 65535 , 65535 | -- | 65535 | -- | ||
Sheet 25: IntplVarXY_s16_s16Xs16Y_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| IntplVarXY_s16_s16Xs16Y_Cnt | B | 18 | IntplVarXY_s16_s16Xs16Y_Cnt_TableX[3] | ||
| IntplVarXY_s16_s16Xs16Y_Cnt | P | 3 | IntplVarXY_s16_s16Xs16Y_Cnt_TableY[3] | ||
Sheet 26: IntplVarXY_s16_s16Xs16Y_Cnt() P
| IntplVarXY_s16_s16Xs16Y_Cnt | TS | -- | ||||||||
| P | Param1 | Param2 | I/P3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | Size8 | input8 | IntplVarXY_s16_s16Xs16Y_Cnt_TableX[3] | IntplVarXY_s16_s16Xs16Y_Cnt_TableY[3] | IntplVarXY_s16_s16Xs16Y_Cnt | IntplVarXY_s16_s16Xs16Y_Cnt | P/F | CPU Cycles | |
| 1 | ( input <= TableX[0] )=False and ( input >= TableX[Size-1] )=True | 3 | 6543 | -7638 , -7494 , -9037 | -733 , -7683 , -8494 | -- | -8494 | -- | ||
| 2 | ( input <= TableX[0] )=True | 3 | -32768 | 6389 , 8037 , 6892 | 7399 , 7290 , 8044 | -- | 7399 | -- | ||
| 3 | ( input >= TableX[Size-1] )=False and ( TableX[index+1] < input )=True and ( TableX[index+1] < input )=False and (diffX == 0)=False | 3 | 443 | -6282 , -2920 , 500 | 8900 , 6920 , 2682 | -- | 2753 | -- | ||
Sheet 27: IntplVarXY_s16_s16Xs16Y_Cnt() B
| IntplVarXY_s16_s16Xs16Y_Cnt | TS | -- | ||||||||
| B | Param1 | Param2 | I/P3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | Size8 | input8 | IntplVarXY_s16_s16Xs16Y_Cnt_TableX[3] | IntplVarXY_s16_s16Xs16Y_Cnt_TableY[3] | IntplVarXY_s16_s16Xs16Y_Cnt | IntplVarXY_s16_s16Xs16Y_Cnt | P/F | CPU Cycles | |
| 1 | param 1 default | 3 | 6543 | -7638 , -7494 , -9037 | -733 , -7683 , -8494 | -- | -8494 | -- | ||
| 2 | param 2 min | 3 | -32768 | 6389 , 8037 , 6892 | 7399 , 7290 , 8044 | -- | 7399 | -- | ||
| 3 | param 2 max | 3 | 32767 | -5628 , -7892 , -8937 | 2783 , 7949 , 6389 | -- | 6389 | -- | ||
| 4 | param 2 zero | 3 | 0 | 5648 , 7037 , 8037 | -5628 , -7238 , -6289 | -- | -5628 | -- | ||
| 5 | param 2 neg | 3 | -1234 | -7383 , -6849 , -6839 | -6383 , -7289 , -4523 | -- | -4523 | -- | ||
| 6 | param 2 pos | 3 | 2422 | 6783 , 8003 , 6289 | -7638 , -7494 , -9037 | -- | -7638 | -- | ||
| 7 | I/p 3 min | 3 | -5544 | -32768 , -32768 , -32768 | 6389 , 8037 , 6892 | -- | 6892 | -- | ||
| 8 | I/p 3 max | 3 | 4235 | 32767 , 32767 , 32767 | -5628 , -7892 , -8937 | -- | -5628 | -- | ||
| 9 | I/p 3 zero | 3 | -7443 | 0 , 0, 0 | 5648 , 7037 , 8037 | -- | 5648 | -- | ||
| 10 | I/p 3 neg | 3 | 2342 | -4176 , -7282 , -6728 | -7383 , -6849 , -6839 | -- | -6839 | -- | ||
| 11 | I/p 3 pos | 3 | -6343 | 5373 , 4279 , 8037 | 6783 , 8003 , 6289 | -- | 6783 | -- | ||
| 12 | I/p 4 min | 3 | 3242 | -733 , -7683 , -8494 | -32768 , -32768 , -32768 | -- | -32768 | -- | ||
| 13 | I/p 4 max | 3 | -6743 | 7399 , 7290 , 8044 | 32767 , 32767 , 32767 | -- | 32767 | -- | ||
| 14 | I/p 4 zero | 3 | 4234 | 2783 , 7949 , 6389 | 0 , 0, 0 | -- | 0 | -- | ||
| 15 | I/p 4 neg | 3 | -8744 | -5628 , -7238 , -6289 | -4176 , -7282 , -6728 | -- | -4176 | -- | ||
| 16 | I/p 4 pos | 3 | 4123 | -6383 , -7289 , -4523 | 5373 , 4279 , 8037 | -- | 8037 | -- | ||
| 17 | All min | 3 | -32768 | -32768 , -32768 , -32768 | -32768 , -32768 , -32768 | -- | -32768 | -- | ||
| 18 | All max | 3 | 32767 | 32767 , 32767 , 32767 | 32767 , 32767 , 32767 | -- | 32767 | -- | ||
Sheet 28: IntplVarXY_s16_u16Xs16Y_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| IntplVarXY_s16_u16Xs16Y_Cnt | B | 14 | IntplVarXY_s16_u16Xs16Y_Cnt_TableX[3] | ||
| IntplVarXY_s16_u16Xs16Y_Cnt | P | 3 | IntplVarXY_s16_u16Xs16Y_Cnt_TableY[3] | ||
Sheet 29: IntplVarXY_s16_u16Xs16Y_Cnt() P
| IntplVarXY_s16_u16Xs16Y_Cnt | TS | -- | ||||||||
| P | Param1 | Param2 | I/P3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | Size9 | input9 | IntplVarXY_s16_u16Xs16Y_Cnt_TableX[3] | IntplVarXY_s16_u16Xs16Y_Cnt_TableY[3] | IntplVarXY_s16_u16Xs16Y_Cnt | IntplVarXY_s16_u16Xs16Y_Cnt | P/F | CPU Cycles | |
| 1 | ( input <= TableX[0] )=True | 3 | 6433 | 7037 , 7393 , 2890 | 7840 , 8904 , 5683 | -- | 7840 | -- | ||
| 2 | ( input <= TableX[0] )=False and ( input >= TableX[Size-1] )=True | 3 | 65535 | 2728 , 3893 , 4793 | 8936 , 7893 , 4728 | -- | 4728 | -- | ||
| 3 | ( input >= TableX[Size-1] )=False and ( TableX[index+1] < input )=True and ( TableX[index+1] < input )=False and (diffX == 0)=False | 3 | 4234 | 3333 , 4000 , 6389 | -6238 , -9628 , -1822 | -- | -8864 | -- | ||
Sheet 30: IntplVarXY_s16_u16Xs16Y_Cnt() B
| IntplVarXY_s16_u16Xs16Y_Cnt | TS | -- | ||||||||
| B | Param1 | Param2 | I/P3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | Size9 | input9 | IntplVarXY_s16_u16Xs16Y_Cnt_TableX[3] | IntplVarXY_s16_u16Xs16Y_Cnt_TableY[3] | IntplVarXY_s16_u16Xs16Y_Cnt | IntplVarXY_s16_u16Xs16Y_Cnt | P/F | CPU Cycles | |
| 1 | param 1 default | 3 | 6433 | 7037 , 7393 , 2890 | 7840 , 8904 , 5683 | -- | 7840 | -- | ||
| 2 | param 2 min | 3 | 0 | 8390 , 8037 , 1781 | -8036 , -5637 , -3738 | -- | -8036 | -- | ||
| 3 | param 2 max | 3 | 65535 | 2728 , 3893 , 4793 | 8936 , 7893 , 4728 | -- | 4728 | -- | ||
| 4 | param 2 pos | 3 | 6452 | 5729 , 8947 , 3683 | -7937 , -5738 , -7933 | -- | -7933 | -- | ||
| 5 | I/p 3 min | 3 | 7653 | 0 , 0, 0 | 6830 , 8903 , 5827 | -- | 5827 | -- | ||
| 6 | I/p 3 max | 3 | 9787 | 65535 , 65535 , 65535 | -7944 , -5683 , -6829 | -- | -7944 | -- | ||
| 7 | I/p 3 pos | 3 | 3436 | 8356 , 5623 , 8307 | 5782 , 7936 , 2682 | -- | 5782 | -- | ||
| 8 | I/p 4 min | 3 | 7565 | 9078 , 6383 , 8047 | -32768 , -32768 , -32768 | -- | -32768 | -- | ||
| 9 | I/p 4 max | 3 | 3423 | 5279 , 8037 , 4894 | 32767 , 32767 , 32767 | -- | 32767 | -- | ||
| 10 | I/p 4 zero | 3 | 5444 | 7292 , 8037 , 1892 | 0, 0, 0 | -- | 0 | -- | ||
| 11 | I/p 4 neg | 3 | 4234 | 3333 , 8047 , 6389 | -6238 , -9628 , -1822 | -- | -6885 | -- | ||
| 12 | I/p 4 pos | 3 | 1231 | 5555 , 6666 , 7777 | 6399 , 7803 , 5893 | -- | 6399 | -- | ||
| 13 | All min | 3 | 0 | 0 , 0, 0 | -32768 , -32768 , -32768 | -- | -32768 | -- | ||
| 14 | All max | 3 | 65535 | 65535 , 65535 , 65535 | 32767 , 32767 , 32767 | -- | 32767 | -- | ||
Sheet 31: IntplFxdX_u16_u16Xu16Y_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| IntplFxdX_u16_u16Xu16Y_Cnt | B | 12 | IntplFxdX_u16_u16Xu16Y_Cnt_TableY[3] | ||
| IntplFxdX_u16_u16Xu16Y_Cnt | P | 4 | |||
Sheet 32: IntplFxdX_u16_u16Xu16Y_Cnt() P
| IntplFxdX_u16_u16Xu16Y_Cnt | TS | -- | ||||||||
| P | Param1 | Param2 | Param3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | DeltaX10 | Size10 | input10 | IntplFxdX_u16_u16Xu16Y_Cnt_TableY[3] | IntplFxdX_u16_u16Xu16Y_Cnt | IntplFxdX_u16_u16Xu16Y_Cnt | P/F | CPU Cycles | |
| 1 | (DeltaX == 0)=True | 0 | 3 | 24534 | 7917 , 6193 , 8044 | -- | 7917 | -- | ||
| 2 | (DeltaX == 0)=False and ( input <= 0 )=False and ( input >= DeltaX * (Size-1) )=False | 65535 | 3 | 365 | 100 , 100, 100 | -- | 100 | -- | ||
| 3 | ( input <= 0 )=True | 564 | 3 | 0 | 7892 , 1682 , 8027 | -- | 7892 | -- | ||
| 4 | ( input >= DeltaX * (Size-1) )=True | 634 | 3 | 47534 | 6829 , 7936 , 6926 | -- | 6926 | -- | ||
Sheet 33: IntplFxdX_u16_u16Xu16Y_Cnt() B
| IntplFxdX_u16_u16Xu16Y_Cnt | TS | -- | ||||||||
| B | Param1 | Param2 | Param3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | DeltaX10 | Size10 | input10 | IntplFxdX_u16_u16Xu16Y_Cnt_TableY[3] | IntplFxdX_u16_u16Xu16Y_Cnt | IntplFxdX_u16_u16Xu16Y_Cnt | P/F | CPU Cycles | |
| 1 | param 1 min | 0 | 3 | 24534 | 7917 , 6193 , 8044 | -- | 7917 | -- | ||
| 2 | param 1 max | 65535 | 3 | 365 | 100 , 100, 100 | -- | 100 | -- | ||
| 3 | param 1 pos | 3435 | 3 | 544 | 800 , 900 , 1000 | -- | 815 | -- | ||
| 4 | param 2 default | 634 | 3 | 47534 | 6829 , 7936 , 6926 | -- | 6926 | -- | ||
| 5 | param 3 min | 564 | 3 | 0 | 7892 , 1682 , 8027 | -- | 7892 | -- | ||
| 6 | param 3 max | 4324 | 3 | 65535 | 6822 , 7922 , 8027 | -- | 8027 | -- | ||
| 7 | param 3 pos | 6756 | 3 | 4232 | 111 , 6778 , 7681 | -- | 4287 | -- | ||
| 8 | I/p 4 min | 4234 | 3 | 6767 | 0 , 0, 0 | -- | 0 | -- | ||
| 9 | I/p 4 max | 7955 | 3 | 4234 | 65535 , 65535 , 65535 | -- | 65535 | -- | ||
| 10 | I/p 4 pos | 2643 | 3 | 6456 | 6784 , 7943 , 7689 | -- | 7689 | -- | ||
| 11 | All min | 0 | 3 | 0 | 0 , 0, 0 | -- | 0 | -- | ||
| 12 | All max | 65535 | 3 | 65535 | 65535 , 65535 , 65535 | -- | 65535 | -- | ||
Sheet 34: IntplFxdX_u16_s16Xu16Y_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| IntplFxdX_u16_s16Xu16Y_Cnt | B | 16 | IntplFxdX_u16_s16Xu16Y_Cnt_TableY[3] | ||
| IntplFxdX_u16_s16Xu16Y_Cnt | P | 4 | |||
Sheet 35: IntplFxdX_u16_s16Xu16Y_Cnt() P
| IntplFxdX_u16_s16Xu16Y_Cnt | TS | -- | ||||||||
| P | Param1 | Param2 | Param3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | DeltaX11 | Size11 | input11 | IntplFxdX_u16_s16Xu16Y_Cnt_TableY[3] | IntplFxdX_u16_s16Xu16Y_Cnt | IntplFxdX_u16_s16Xu16Y_Cnt | P/F | CPU Cycles | |
| 1 | (DeltaX == 0)=False and ( input <= 0 )=False and ( input >= DeltaX * (Size-1) )=True | -32768 | 3 | 4903 | 573 , 7037 , 3789 | -- | 3789 | -- | ||
| 2 | ( input <= 0 )=True | 32767 | 3 | -5789 | 789 , 7017 , 782 | -- | 789 | -- | ||
| 3 | (DeltaX == 0)=True | 0 | 3 | -6896 | 68 , 806 , 29 | -- | 68 | -- | ||
| 4 | ( input >= DeltaX * (Size-1) )=False | 8950 | 3 | 8003 | 1682 , 378 , 793 | -- | 515 | -- | ||
Sheet 36: IntplFxdX_u16_s16Xu16Y_Cnt() B
| IntplFxdX_u16_s16Xu16Y_Cnt | TS | -- | ||||||||
| B | Param1 | Param2 | Param3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | DeltaX11 | Size11 | input11 | IntplFxdX_u16_s16Xu16Y_Cnt_TableY[3] | IntplFxdX_u16_s16Xu16Y_Cnt | IntplFxdX_u16_s16Xu16Y_Cnt | P/F | CPU Cycles | |
| 1 | param 1 min | -32768 | 3 | 4903 | 573 , 7037 , 3789 | -- | 3789 | -- | ||
| 2 | param 1 max | 32767 | 3 | -5789 | 789 , 7017 , 782 | -- | 789 | -- | ||
| 3 | param 1 zero | 0 | 3 | -6896 | 68 , 806 , 29 | -- | 68 | -- | ||
| 4 | param 1 neg | -6738 | 3 | 1789 | 38 , 89 , 792 | -- | 792 | -- | ||
| 5 | param 1 pos | 7922 | 3 | -8923 | 783 , 8037 , 783 | -- | 783 | -- | ||
| 6 | param 2 default | 8950 | 3 | 8003 | 1682 , 378 , 793 | -- | 515 | -- | ||
| 7 | param 3 min | -7839 | 3 | -32768 | 5793 , 2990 , 8074 | -- | 5793 | -- | ||
| 8 | param 3 max | 6738 | 3 | 32767 | 7923 , 8036 , 2782 | -- | 2782 | -- | ||
| 9 | param 3 zero | -6829 | 3 | 0 | 5728 , 8932 , 7937 | -- | 5728 | -- | ||
| 10 | param 3 neg | 4389 | 3 | -26819 | 5729 , 8037 , 5728 | -- | 5729 | -- | ||
| 11 | param 3 pos | -7939 | 3 | 7939 | 8593 , 7893 , 8027 | -- | 8027 | -- | ||
| 12 | I/p 4 min | 2782 | 3 | -5829 | 0, 0, 0 | -- | 0 | -- | ||
| 13 | I/p 4 max | -5829 | 3 | 1671 | 65535 , 65535 , 65535 | -- | 65535 | -- | ||
| 14 | I/p 4 pos | 1789 | 3 | -7923 | 7839 , 5738 , 9043 | -- | 7839 | -- | ||
| 15 | All min | -32768 | 3 | -32768 | 0, 0, 0 | -- | 0 | -- | ||
| 16 | All max | 32767 | 3 | 32767 | 65535 , 65535 , 65535 | -- | 65535 | -- | ||
Sheet 37: IntplFxdX_s16_s16Xs16Y_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| IntplFxdX_s16_s16Xs16Y_Cnt | B | 18 | IntplFxdX_s16_s16Xs16Y_Cnt_TableY[3] | ||
| IntplFxdX_s16_s16Xs16Y_Cnt | P | 4 | |||
Sheet 38: IntplFxdX_s16_s16Xs16Y_Cnt() P
| IntplFxdX_s16_s16Xs16Y_Cnt | TS | -- | ||||||||
| P | Param1 | Param2 | Param3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | DeltaX12 | Size12 | input12 | IntplFxdX_s16_s16Xs16Y_Cnt_TableY[3] | IntplFxdX_s16_s16Xs16Y_Cnt | IntplFxdX_s16_s16Xs16Y_Cnt | P/F | CPU Cycles | |
| 1 | (DeltaX == 0)=False and ( input <= 0 )=True | -32768 | 3 | -1111 | 6833 , 8027 , 5782 | -- | 6833 | -- | ||
| 2 | ( input <= 0 )=False and ( input >= DeltaX * (Size-1) )=False | 32767 | 3 | 2222 | -5672 , -6821 , -782 | -- | -5749 | -- | ||
| 3 | (DeltaX == 0)=True | 0 | 3 | -3333 | 3792 , 8090 , 7892 | -- | 3792 | -- | ||
| 4 | ( input >= DeltaX * (Size-1) )=True | -6839 | 3 | 4444 | -8027 , -6922 , -7020 | -- | -7020 | -- | ||
Sheet 39: IntplFxdX_s16_s16Xs16Y_Cnt() B
| IntplFxdX_s16_s16Xs16Y_Cnt | TS | -- | ||||||||
| B | Param1 | Param2 | Param3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | DeltaX12 | Size12 | input12 | IntplFxdX_s16_s16Xs16Y_Cnt_TableY[3] | IntplFxdX_s16_s16Xs16Y_Cnt | IntplFxdX_s16_s16Xs16Y_Cnt | P/F | CPU Cycles | |
| 1 | param 1 min | -32768 | 3 | -1111 | 6833 , 8027 , 5782 | -- | 6833 | -- | ||
| 2 | param 1 max | 32767 | 3 | 2222 | -5672 , -6821 , -782 | -- | -5749 | -- | ||
| 3 | param 1 zero | 0 | 3 | -3333 | 3792 , 8090 , 7892 | -- | 3792 | -- | ||
| 4 | param 1 neg | -6839 | 3 | 4444 | -8027 , -6922 , -7020 | -- | -7020 | -- | ||
| 5 | param 1 pos | 7839 | 3 | -5555 | 5829 , 8027 , 5783 | -- | 5829 | -- | ||
| 6 | param 2 default | -7484 | 3 | 6666 | -8027 , -7027 , -4027 | -- | -4027 | -- | ||
| 7 | param 3 min | 6839 | 3 | -32768 | 5892 , 2789 , 1781 | -- | 5892 | -- | ||
| 8 | param 3 max | -2728 | 3 | 32767 | -7922 , -6811 , -5702 | -- | -5702 | -- | ||
| 9 | param 3 zero | 1000 | 3 | 0 | 5729 , 8027 , 1671 | -- | 5729 | -- | ||
| 10 | param 3 neg | -2000 | 3 | -5839 | -5729 , -7922 , -1678 | -- | -5729 | -- | ||
| 11 | param 3 pos | 3000 | 3 | 8926 | 6829 , 2782 , 7027 | -- | 7027 | -- | ||
| 12 | I/p 4 min | -4000 | 3 | -7777 | -32768 , -32768 , -32768 | -- | -32768 | -- | ||
| 13 | I/p 4 max | 5000 | 3 | 8888 | 32767 , 32767 , 32767 | -- | 32767 | -- | ||
| 14 | I/p 4 zero | -6000 | 3 | -9999 | 0, 0, 0 | -- | 0 | -- | ||
| 15 | I/p 4 neg | 7000 | 3 | 6545 | -7683 , -3527 , -8936 | -- | -3798 | -- | ||
| 16 | I/p 4 pos | -8000 | 3 | -5764 | 4763 , 6822 , 8903 | -- | 4763 | -- | ||
| 17 | All min | -32768 | 3 | -32768 | -32768 , -32768 , -32768 | -- | -32768 | -- | ||
| 18 | All max | 32767 | 3 | 32767 | 32767 , 32767 , 32767 | -- | 32767 | -- | ||
Sheet 40: IntplFxdX_s16_u16Xs16Y_Cnt
| |||||
| Nexteer EPS Unit Test Tool | |||||
| Rev:2.7b | |||||
| Test Setup | |||||
| Number Of Calibrations | 0 | ||||
| Number Of Calibration Sets | 0 | ||||
| Calibration Sheet | |||||
| Function(s) Under Test | Variables | Function Stubs | |||
| Function Name | TestType | Test Vectors | Set | Read | Function Name |
| IntplFxdX_s16_u16Xs16Y_Cnt | B | 14 | IntplFxdX_s16_u16Xs16Y_Cnt_TableY[3] | ||
| IntplFxdX_s16_u16Xs16Y_Cnt | P | 4 | |||
Sheet 41: IntplFxdX_s16_u16Xs16Y_Cnt() P
| IntplFxdX_s16_u16Xs16Y_Cnt | TS | -- | ||||||||
| P | Param1 | Param2 | Param3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | DeltaX13 | Size13 | input13 | IntplFxdX_s16_u16Xs16Y_Cnt_TableY[3] | IntplFxdX_s16_u16Xs16Y_Cnt | IntplFxdX_s16_u16Xs16Y_Cnt | P/F | CPU Cycles | |
| 1 | (DeltaX == 0)=True | 0 | 3 | 4444 | 6782 , 8027 , 2682 | -- | 6782 | -- | ||
| 2 | (DeltaX == 0)=False and ( input <= 0 )=False and ( input >= DeltaX * (Size-1) )=False | 65535 | 3 | 65533 | 32765 , 32765 , 32765 | -- | 32765 | -- | ||
| 3 | ( input <= 0 )=True | 1344 | 3 | 0 | 15761 , 6789 , 2892 | -- | 15761 | -- | ||
| 4 | ( input >= DeltaX * (Size-1) )=True | 645 | 3 | 65535 | -6822 , -2682 , -7802 | -- | -7802 | -- | ||
Sheet 42: IntplFxdX_s16_u16Xs16Y_Cnt() B
| IntplFxdX_s16_u16Xs16Y_Cnt | TS | -- | ||||||||
| B | Param1 | Param2 | Param3 | I/P4 | Function Return Val | Expected Return Val | Test Status | Perf. Metrics | Comments | |
| Vector Number | Vector Description | DeltaX13 | Size13 | input13 | IntplFxdX_s16_u16Xs16Y_Cnt_TableY[3] | IntplFxdX_s16_u16Xs16Y_Cnt | IntplFxdX_s16_u16Xs16Y_Cnt | P/F | CPU Cycles | |
| 1 | param 1 min | 0 | 3 | 4444 | 6782 , 8027 , 2682 | -- | 6782 | -- | ||
| 2 | param 1 max | 65535 | 3 | 65533 | 32765 , 32765 , 32765 | -- | 32765 | -- | ||
| 3 | param 1 pos | 4553 | 3 | 2222 | 5785 , 7899 , 9047 | -- | 6816 | -- | ||
| 4 | param 2 default | 123 | 3 | 111 | -600 , -600 , -600 | -- | -600 | -- | ||
| 5 | param 3 min | 1344 | 3 | 0 | 15761 , 6789 , 2892 | -- | 15761 | -- | ||
| 6 | param 3 max | 645 | 3 | 65535 | -6822 , -2682 , -7802 | -- | -7802 | -- | ||
| 7 | param 3 pos | 4234 | 3 | 6342 | 8853 , 8027 , 3728 | -- | 5887 | -- | ||
| 8 | I/p 4 min | 9780 | 3 | 100 | -32768 , -32768 , -32768 | -- | -32768 | -- | ||
| 9 | I/p 4 max | 5345 | 3 | 200 | 32767 , 32767 , 32767 | -- | 32767 | -- | ||
| 10 | I/p 4 zero | 6435 | 3 | 300 | 0, 0, 0 | -- | 0 | -- | ||
| 11 | I/p 4 neg | 4123 | 3 | 400 | -7282 , -6822 , -6922 | -- | -7238 | -- | ||
| 12 | I/p 4 pos | 9890 | 3 | 500 | 6238 , 8903 , 2562 | -- | 6372 | -- | ||
| 13 | All min | 0 | 3 | 0 | -32768 , -32768 , -32768 | -- | -32768 | -- | ||
| 14 | All max | 65535 | 3 | 65535 | 32767 , 32767 , 32767 | -- | 32767 | -- | ||