MotorVelocity_MDD

Module -- Motor Velocity

High-Level Description

This function is responsible for calculating motor velocity from the sine and cosine motor position sensor signals.

Based on HighLevelDesignDocument (State Dependant Runnables_BMW_Future.xlsx), Runnables shown in different application segments are placed in different source files. For MtrVel, FDD Ver 007, HLDD has 4 runnables, two of which are in ASILD listed as MtrVel_Per1() and MtrVel_Per2(). And two of them are in ASILB’(D) listed as MtrVel2_Per1() and MtrVel2_Per2(). This document is responsible for ASILD runnables.

Figures

Diagram – Function Data Sharing

This diagram shows all data that is shared between functions within the module.

No Shared Data

Diagram – MtrVel_Per1

This diagram describes the functional characteristics and data flow of a given 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 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.

* Note: These ranges are based on the range of the normalized sine and cosine global inputs, which in turn are based on the maximum amount of signal variation that can be caused by temperature changes on the MSB signals.

User defined typedef definition/declaration

This section documents any user types uniquely used for the module.

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.

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

Global

This section lists the global constants used by the module. For details on global constants, refer to the Data Dictionary for the application.

Module specific Lookup Tables Constants

(This is for lookup tables (arrays) with fixed values, same name as other tables)

Functions/Macros used by the Sub-Modules

Library Functions / Macros

The library functions / Macros that are called by the various sub modules are identified below,

1. FPM_FixedToFloat_m()

2. FPM_FloatToFixed_m()

3. FMP_Fix_m()

4. Max_m()

5. Abs_s16_m()

6. Abs_f32_m()

7. IntplVarXY_u16_u16Xu16Y_Cnt()

8. LPF_SvUpdate_s16InFixKTrunc_m()

9. LPF_OpUpdate_s16InFixKTrunc_m()

10. Rte_Call_NxtrDiagMgr_GetNTCFailed

11. Rte_Call_NxtrDiagMgr_SetNTCStatus

12. TableSize_m()

Data Hiding Functions

The data hiding functions / macros used in this module are identified below,

Local Functions/Macros Used by this MDD only

(Note if they are defined in another source file, then reference the appropriate header file)

The local functions/macros in this module are identified below,

1. Square_m(x) ((x)*(x))

2. CalcCoarseVel()

3. CorrectVel()

4. MtrVelBlend()

5. RegressionFit()

Software Module Implementation

Initialization Functions

Init: MtrVel_Init1

Design Rationale

None

Module Outputs

None

Module Internal

None

Description

Periodic Functions

Per: MtrVel_Per1

Design Rationale

Coarse and Fine Velocity Calculations

A “coarse” motor velocity signal is calculated which is simply calculated from (change in averaged motor position) / (change in averaged time).

The “fine” motor velocity signal has inherent error at high speeds due to the nature of the algorithm. Because of the way the calculation is done and the fact that the samples are done every 1mS, the maximum velocity that this algorithm can calculate is +/-pi rad/ms ~ +/- 3142 rad/sec. Additionally, there is significant error in the calculation as velocity increases to this limit. For this reason, a correction is calculated and applied to the fine velocity to increase the accuracy up to a certain speed, and a blending is done so that “fine” velocity is used at lower speeds when it is accurate, and “coarse” velocity is used at high speeds.

Unit Testing Considerations

The design of this module was done with physical motor velocity considerations taken into account. For example, the limits on the inputs to some of the local functions are based on the physical system. Assuming the motor can rotate at a maximum of +/- 1350 Rads/Sec, the design only needs to accommodate a certain “change in position” from the last loop. Similarly, a “change in time” from the last loop will always correspond to the calculation loop rate within a tolerance. This was where the limits for the Coarse and Fine velocity functions were derived. All unit-testing test vectors should be designed in such a way as to conform to these physical limitations. Additionally, for any use of combinations of the sin and cos signals, the standard sin vs cos relationship may need to be followed (e.g. sin and cos are never both “0” at the same point in time).

Program Flow Start

Rte_Call_MtrVel_Per1_CP0_CheckpointReached()Store Module Inputs to Local copies

SinAvg_Uls_T_s2p13 as sint16

CosAvg_Uls_T_s2p13 as sint16

PosAvg_Rev_T_u0p16 as uint16

TimeAvg_uS_T_u16p0 as uint16

MtrVel_ActiveBufSet_Cnt_M_u08 = (MtrVel_SnapShotSet_Cnt_G_u08 ^ 1u) & 1u

AsstAssemPol_Cnt_T_s08 = Rte_IRead_MtrVel_Per1_AsstAssemPol_Cnt_s08()

VehSpd_Kph_T_f32 = Rte_IRead_MtrVel_Per1_VehSpd_Kph_f32()

VehSpd_Kph_T_u9p7 = FPM_FloatToFixed_m(VehSpd_Kph_T_f32, u9p7_T);

Rte_Call_NxtrDiagMgr_GetNTCFailed(NTC_Num_PriMSB_SinCosCorr,&MtrPosFault1_Cnt_T_lgc)

Rte_Call_NxtrDiagMgr_GetNTCFailed(NTC_Num_PriVsSec_SinCosCorr, &MtrPosFault2_Cnt_T_lgc)

Calculate Raw Motor Velocity

Store Local copy of outputs into Module Outputs

Rte_IWrite_MtrVel_Per1_MRFMtrVel_MtrRadpS_f32(MtrVel_MtrRadpS_T_f32)

MtrVel_MtrRadpS_T_f32 = AsstAssemPol_Cnt_T_s08 * MtrVel_MtrRadpS_T_f32

Rte_IWrite_MtrVel_Per1_CRFMtrVel_MtrRadpS_f32(MtrVel_MtrRadpS_T_f32)

HwVel_HwRadpS_T_f32 = MtrVel_MtrRadpS_T_f32 * k_GearRatio_Uls_f32

HwVel_HwRadpS_M_f32 = Limit_m(HwVel_HwRadpS_T_f32, D_HWVELLOLMT_HWRADPS_F32, D_HWVELHILMT_HWRADPS_F32)

Rte_IWrite_MtrVel_Per1_HandwheelVel_HwRadpS_f32 (MtrVel_MtrRadpS_T_f32)

Rte_IWrite_MtrVel_Per1_HwVelValid_Cnt_lgc(HwVelValid_Cnt_T_lgc)

Rte_IWrite_MtrVel_Per1_MRFMotorVelUnfiltered_MtrRadpS_f32(WestBlendedMtrVel_MtrRadpS_D_f32)

Rte_IWrite_MtrVel_Per1_SysCMotorVelMRF_MtrRadpS_f32(MtrVel_MtrRadpS_M_f32)

Rte_IWrite_MtrVel_Per1_SysCHandwheelVel_HwRadpS_f32(HwVel_HwRadpS_M_f32)

Program Flow End

Rte_Call_MtrVel_Per1_CP1_CheckpointReached()

Periodic Functions

Per: MtrVel_Per2

Design Rationale

Program Flow Start

Rte_Call_MtrVel_Per2_CP0_CheckpointReached()Store Module Inputs to Local copies

SysC_DiagMtrVelMRF_MtrRadpS_T_f32 = Rte_IRead_MtrVel_Per2_SysCDiagMtrVelMRF_MtrRadpS_f32()

SysC_DiagHandWheelVel_HwRadpS_T_f32 = Rte_IRead_MtrVel_Per2_SysCDiagHandWheelVel_HwRadpS_f32()

Calculate Raw Motor Velocity

Program Flow End

Rte_Call_MtrVel_Per2_CP1_CheckpointReached()

Fault Recovery Functions

None

Shutdown Functions

None

Interrupt Functions

None

Serial Communication Functions

None

Local Function/Macro Definitions

If these are numerous and defined in a separate source file then reference the source file only.

Calculation Coarse Velocity

Description

Correct Velocity

Design Rationale

This function will calculate and apply a correction factor to the fine motor velocity. This will increase the range of speeds over which the fine motor velocity is accurate. The calculation of the correction term is shown below:

Correction Term = A0 + N_1P/(E_1P - w^2) + N_2P/(E_2P - w^2)

A0 = 0.5249978317

N_1P = 0.09425018578 / SampleTime^2 = 94250.18578

E_1P = 3 1.270451499 / SampleTime^2 = 1270451.499

N_2P = 1.484093006 / SampleTime^2 = 1484093.006

E_2P = 3.702672882 / SampleTime^2 = 3702672.882

w = Calculated Fine Motor Velocity

Description

Motor Velocity Blend

Description

Regression Fit

* 200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

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

Execution Requirements for Serial Communication Functions

Memory Map Definition Requirements

Sub Modules (Functions)

This table identifies the software segments for functions identified in this module.

Local Functions

This table identifies the software segments for local functions identified in this module.

Known Issues / Limitations With Design

1. In this design, MtrVel3_TimeBuffer_uS_M_u16p0[][] represents a set of independent circular buffers. Each buffer contains a set of continuous timestamps with the most recent timestamp index of each sample set stored in the associated index of MtrVel3_OsBufPos_Cnt_M_u08[] . The design requires monotonically increasing timestamps relative to the starting index value in MtrVel3_OsBufPos_Cnt_M_u08[]. Due to the modulo 65536 behavior of the timestamp, a single timestamp rollover within the active sample set pair is correctly handled by the design. Simultaneous sample points (e.g. ∆t = 0 for consecutive timestamps) are invalid and will result in a divide by zero in the current design. Unit Test vectors for functions which have MtrVel3_TimeBuffer_uS_M_u16p0[4][8] as an input (MtrVel_Per1 and RegressionFit) must provide an input vector value set which conforms to the set of rules in the following table:

Table 1: Time Buffer UTP Constraints

The following *.bas is a VBA function to validate the timestamp data sets.

EXAMPLE TimeStamp Buffer Data Set:

The following buffer timestamp data set provides an example when buffers 0 and 1 are active. Values for buffers 2 and 3 are don’t care values for this example and shown as “X” or “Don’t Care”. The samples within the buffers have subscripts which describe the samples order relative to the newest sample in the buffer (e.g. z-1 indicates that the sample is 1 sample period old, z-2 indicates the sample is 2 sample periods old, etc). Samples of the same relative order within each buffer have the same cell shading applied to aid the reader in locating cross buffer sample pairs.

MtrVel_OldPosBuf_M_u08 = 0

MtrVel_OsBufSelect_M_u08 = 1

MtrVel3_OsBufPos_Cnt_M_u08[0] = 0

MtrVel3_OsBufPos_Cnt_M_u08[1] = 2

MtrVel3_OsBufPos_Cnt_M_u08[2] = Don’t Care

MtrVel3_OsBufPos_Cnt_M_u08[3] = Don’t Care

Table 2: Example UTP TimeBuffer Roll-Over Sample Set

2. The state variables MtrVel_OldPosBuf_M_u08 and MtrVel_OsBufSelect_Cnt_M_u08 have a relationship that is maintained by logic that is executed after their use in RegressionFit(). The RegressionFit() function design requires a valid set of state variables to function properly. Therefore, it is possible to provide an illegal value set for the related state variables in a unit testing environment that will cause an illegal execution of RegressionFit(). All unit test vectors must ensure that MtrVel_OldPosBuf_M_u08 ≠ MtrVel_OsBufSelect_Cnt_M_u08. Failure to do so will result in a divide by 0 exception.

Revision Control Log