LAUNCHXL-F280049C: Is there a problem with dcBus_V that is causing an error in the estimator?

__interrupt void mainISR(void)
{


    motorVars.pwmISRCount++;

    //
    // toggle status LED
    //
    counterLED++;

    if(counterLED > (uint32_t)(USER_ISR_FREQ_Hz / LED_BLINK_FREQ_Hz))
    {
        HAL_toggleLED(halHandle, HAL_GPIO_LED2);
        counterLED = 0;
    }

    //
    // acknowledge the ADC interrupt
    //
    HAL_ackADCInt(halHandle, ADC_INT_NUMBER1);

    //
    // read the ADC data with offsets
    //
    HAL_readADCDataWithOffsets(halHandle, &adcData);

    //
    // remove offsets
    //
    adcData.I_A.value[0] -= motorVars.offsets_I_A.value[0];
    adcData.I_A.value[1] -= motorVars.offsets_I_A.value[1];
    adcData.I_A.value[2] -= motorVars.offsets_I_A.value[2];
    adcData.V_V.value[0] -= motorVars.offsets_V_V.value[0];
    adcData.V_V.value[1] -= motorVars.offsets_V_V.value[1];
    adcData.V_V.value[2] -= motorVars.offsets_V_V.value[2];


    if(motorVars.flagEnableOffsetCalc == false)
    {
        float32_t outMax_V;
        MATH_Vec2 phasor;

        //
        // run Clarke transform on current
        //
        CLARKE_run(clarkeHandle_I, &(adcData.I_A), &(estInputData.Iab_A));

        //
        // run Clarke transform on voltage
        //
        CLARKE_run(clarkeHandle_V, &(adcData.V_V), &(estInputData.Vab_V));

        counterTrajSpeed++;

        if(counterTrajSpeed >= userParams.numIsrTicksPerTrajTick)
        {
            //
            // clear counter
            //
            counterTrajSpeed = 0;

            //
            // run a trajectory for speed reference,
            // so the reference changes with a ramp instead of a step
            //
            TRAJ_run(trajHandle_spd);

            motorVars.speedTraj_Hz = TRAJ_getIntValue(trajHandle_spd);
        }

        estInputData.dcBus_V = adcData.dcBus_V;
        estInputData.speed_ref_Hz = motorVars.speedTraj_Hz;
        estOutputData.oneOverDcBus_invV = 1.0 / estInputData.dcBus_V;

        //
        // run the estimator
        //
        EST_run(estHandle, &estInputData, &estOutputData);

        //
        // get Idq, reutilizing a Park transform used inside the estimator.
        // This is optional, user's Park works as well
        //
        EST_getIdq_A(estHandle, (MATH_Vec2 *)(&(Idq_in_A)));

        //
        // compute angle with delay compensation
        //
        angleDelta_rad = userParams.angleDelayed_sf_sec *
                         estOutputData.fm_lp_rps;

        angleEst_rad = MATH_incrAngle(estOutputData.angle_rad,
                                            angleDelta_rad);

        ANGLE_GEN_run(angleGenHandle, estInputData.speed_ref_Hz);
        angleFoc_rad = ANGLE_GEN_getAngle(angleGenHandle);

        Idq_ref_A.value[0] = IdqSet_A.value[0];
        Idq_ref_A.value[1] = IdqSet_A.value[1];

        //
        // compute the sin/cos phasor using fast RTS function, callable assembly
        //
        phasor.value[0] = cosf(angleFoc_rad);
        phasor.value[1] = sinf(angleFoc_rad);

        //
        // set the phasor in the Park transform
        //
        PARK_setPhasor(parkHandle_I, &phasor);

        //
        // run the Park module
        //
        PARK_run(parkHandle_I, &(estInputData.Iab_A), &(Idq_in_A));

        //
        // run the Id controller
        //
        //
        // Set the Id current controller gain
        //

        ////////////////////////////////////////////////////////////////////////////////////////////////

        PI_run_series(piHandle_Id,
                      Idq_ref_A.value[0] + Idq_offset_A.value[0],
                      Idq_in_A.value[0],
                      0.0,
                      &(Vdq_out_V.value[0]));

        //
        // calculate Iq controller limits, and run Iq controller using fast RTS
        // function, callable assembly
        //
        outMax_V = sqrt((userParams.maxVsMag_V * userParams.maxVsMag_V) -
                        (Vdq_out_V.value[0] * Vdq_out_V.value[0]));

        PI_setMinMax(piHandle_Iq, (-outMax_V), outMax_V);

        PI_run_series(piHandle_Iq,
                      Idq_ref_A.value[1] + Idq_offset_A.value[1],
                      Idq_in_A.value[1],
                      0.0,
                      &(Vdq_out_V.value[1]));

        //
        // set the phasor in the inverse Park transform
        //
        IPARK_setPhasor(iparkHandle, &phasor);

        //
        // run the inverse Park module
        //
        IPARK_run(iparkHandle, &Vdq_out_V, &Vab_out_V);

        //
        // setup the space vector generator (SVGEN) module
        //
        SVGEN_setup(svgenHandle, estOutputData.oneOverDcBus_invV);

        //
        // run the space vector generator (SVGEN) module
        //
        SVGEN_run(svgenHandle, &Vab_out_V, &(pwmData.Vabc_pu));
    }
    else if(motorVars.flagEnableOffsetCalc == true)
    {
        runOffsetsCalculation();
    }

    if(HAL_getPwmEnableStatus(halHandle) == false)
    {
        //
        // clear PWM data
        //
        pwmData.Vabc_pu.value[0] = 0.0;
        pwmData.Vabc_pu.value[1] = 0.0;
        pwmData.Vabc_pu.value[2] = 0.0;
    }

    //
    // write the PWM compare values
    //
    HAL_writePWMData(halHandle, &pwmData);

#ifdef PWMDAC_ENABLE
    //
    // connect inputs of the PWMDAC module.
    //
    HAL_writePWMDACData(halHandle, &pwmDACData);
#endif  // PWMDAC_ENABLE

#ifdef DATALOG_ENABLE
    //
    // call datalog
    //
    DATALOG_updateWithDMA(datalogHandle);

    //
    // Force trig DMA channel to save the data
    //
    HAL_trigDlogWithDMA(halHandle, 0);
    HAL_trigDlogWithDMA(halHandle, 1);
    HAL_trigDlogWithDMA(halHandle, 2);
    HAL_trigDlogWithDMA(halHandle, 3);
#endif  //  DATALOG_ENABLE



    return;
} // end of mainISR() function