LAUNCHXL-F280049C: ADC offset calibration (SDK)

Seemingly HAL_runADCZeroOffsetCalibration() is never being called by the SDK, is01_Intro.c or is05_motor_id.c. The ADC channels are not exactly calibrated prior to runOffsetsCalculation() 50% PWM duty cycle occurs. 

Lab 5 runOffsetsCalculation() does what exactly if the ADC has never been properly calibrated by call to HAL_runADCZeroOffsetCalibration()?  Note the above post divide results 512 (SampleSize) should be divide by 32. Not being critical of SDK only seek to improve the motor ID functionality. 

13.13.1 ADC Zero Offset Calibration

Zero offset error is defined as the difference from 0 that occurs when converting a voltage at VREFLO. The zero offset error can be positive or negative. To correct this error, an adjustment of equal magnitude and opposite polarity is written into the ADCOFFTRIM register. The value contained in this register will be applied before the results are available in the ADC result registers. This operation is fully contained within the ADC core, so the timing of the results will not be affected and the full dynamic range of the ADC will be maintained for any trim value.

Using the GetAdcOffsetTrimOTP(Uint16) function, the ADCOFFTRIM register can be loaded with the factory calibrated offset error correction. The user can modify the ADCOFFTRIM register to compensate for additional offset error induced by the application environment if desired, but this is not typically necessary to achieve datasheet specified performance.

As replied to other threads you posted, the HAL_runADCZeroOffsetCalibration is not used in MotorControlSDK, it's just for the previous devices in motorWare.

The SDK offset calculation does not do the same thing to ADC as HAL_cal does. So the offsets values SDK came up with after motor ID were uneven prior to HAL_cal. That HAL_cal() calibrates the ADC after factory calibration was run prior to oven cooking solder paste and at what ambient temperature, who even knows. 

Please explain what part of SDK function below actually modifies the ADC ADCOFFTRIM  register. It's not a matter of what so much but more a matter of why not and how come. The lab5 function below (offset calculation) is not the same as offset calibration. Best I can tell all it does is zero out many of the FAST estimator motor.vars prior to collecting update motor.vars. So if we end CCS debug session and attempt to launch again with user.h collected motor parameters enable flag (user.h parameters) the motor does not accelerate. ADC offset calibration is the least of the issues in this SDK, though very nicely laid out and coded.   

void runOffsetsCalculation(void)
{
    uint16_t cnt;
    float32_t Vin;
    float32_t invVdcbus;

    if(motorVars.flagEnableSys == true)
    {
      	/* Clear DACH/L lathes and any
      	 * Trip Zone CBC/OSHT fault flags */
      	HAL_clearPWMfaults(halHandle);

        //
        // enable the PWM
        //
        HAL_enablePWM(halHandle);

        //SCIprintf(">>Begin OffsetCalc \n");

        //
        // set to the half of inverse dc bus voltage
        //
        invVdcbus = 2.0 / adcData.dcBus_V;

        //
        // set the 3-phase output PWMs to 50% duty cycle
        //
        pwmData.Vabc_pu.value[0] = 0.0;
        pwmData.Vabc_pu.value[1] = 0.0;
        pwmData.Vabc_pu.value[2] = 0.0;

        for(cnt = 0; cnt < USER_NUM_CURRENT_SENSORS; cnt++)
        {
            //
            // reset current offsets used
            //
            motorVars.offsets_I_A.value[cnt] = 0.0;

            //
            // run current offset estimation
            //
            FILTER_FO_run(filterHandle_I[cnt],
                          adcData.I_A.value[cnt]);

        }

        for(cnt = 0; cnt < USER_NUM_VOLTAGE_SENSORS; cnt++)
        {
            //
            // reset voltage offsets used
            //
            motorVars.offsets_V_V.value[cnt] = 0.0;

            Vin = adcData.V_V.value[cnt] * invVdcbus;

            //
            // run voltage offset estimation
            //
            FILTER_FO_run(filterHandle_V[cnt], Vin);

        }

        offsetCalcCount++;

        if(offsetCalcCount >= offsetCalcWaitTime)
        {
            for(cnt = 0; cnt < USER_NUM_CURRENT_SENSORS; cnt++)
            {
                //
                // get calculated current offsets from filter
                //
                motorVars.offsets_I_A.value[cnt] =
                        FILTER_FO_get_y1(filterHandle_I[cnt]);

                //
                // clear current filters
                //
                FILTER_FO_setInitialConditions(filterHandle_I[cnt],
                                              motorVars.offsets_I_A.value[cnt],
                                              motorVars.offsets_I_A.value[cnt]);

            }

            for(cnt = 0; cnt < USER_NUM_VOLTAGE_SENSORS; cnt++)
            {
                //
                // get calculated voltage offsets from filter
                //
                motorVars.offsets_V_V.value[cnt] =
                        FILTER_FO_get_y1(filterHandle_V[cnt]);

                //
                // clear voltage filters
                //
                FILTER_FO_setInitialConditions(filterHandle_V[cnt],
                                              motorVars.offsets_V_V.value[cnt],
                                              motorVars.offsets_V_V.value[cnt]);
            }

            offsetCalcCount = 0;
            motorVars.flagEnableOffsetCalc = false;

            SCIprintf(">>End OffsetCalc \n");

            //
            // disable the PWM
            //
            HAL_disablePWM(halHandle);

        }
    }

    return;
} // end of runOffsetsCalculation() function