motor_ctl-1/2.MotorDrive/Source/pwm.c

/************************************************************************
 Project:             Welling Motor Control Paltform
 Filename:            pwm.c
 Partner Filename:    pwm.h
 Description:         SVPWM and over voltage modulation
 Complier:            IAR Embedded Workbench for ARM 7.80.4
 CPU TYPE :           GD32F3x0
*************************************************************************
 Copyright (c) 2018 Welling Motor Technology(Shanghai) Co. Ltd.
 All rights reserved.
*************************************************************************
*************************************************************************
 Revising History (ECL of this file):

************************************************************************/
/************************************************************************
 Beginning of File, do not put anything above here except notes
 Compiler Directives:
************************************************************************/
#ifndef _PWM_C_
#define _PWM_C_
#endif
/************************************************************************
Include File
************************************************************************/
#include "syspar.h"
#include "user.h"

/************************************************************************
 Private Variables
*************************************************************************/
SWORD pwm_pvt_sw1st_Cur_Smpl_Ct = 0;
SWORD pwm_pvt_sw2nd_Cur_Smpl_Ct = 0;
SWORD pwm_pvt_swMin_Double_Cur_Smpl_Pu = 0;
SWORD pwm_pvt_swMin_Cur_Smpl_Ct = 0;
SWORD pwm_pvt_swMin_Cur_Smpl_Pu = 0;

/************************************************************************
 Constant Table:
************************************************************************/

/************************************************************************
 Exported Functions:
************************************************************************/

/************************************************************************
 Function: pwm_voInit;
 Description: pwm generation initial;
 Call by: functions in main loop;
 Input Variables: N/A;
 Output/Return Variables: N/A;
 Subroutine Call: N/A;
 Reference: N/A;
************************************************************************/
void pwm_voInit(void)
{


    pwm_stGenOut.swUalphaPu = 0; // Q14
    pwm_stGenOut.swUbetaPu = 0;  // Q14
    pwm_stGenOut.uwNewSectorNum = 0;
    pwm_stGenOut.uwNewTIM1COMPR[0] = HW_HHPWM_PERIOD;
    pwm_stGenOut.uwNewTIM1COMPR[1] = HW_HHPWM_PERIOD;
    pwm_stGenOut.uwNewTIM1COMPR[2] = HW_HHPWM_PERIOD;
    pwm_stGenOut.uwNewTIM1COMPR[3] = HW_HHPWM_PERIOD;
    pwm_stGenOut.uwNewTIM1COMPR[4] = HW_HHPWM_PERIOD;
    pwm_stGenOut.uwNewTIM1COMPR[5] = HW_HHPWM_PERIOD;
    pwm_stGenOut.uwFirstTrigCOMPR = HW_HHHPWM_PERIOD;
    pwm_stGenOut.uwSecondTrigCOMPR = HW_HHPWM_PERIOD + HW_HHHPWM_PERIOD;
    pwm_stGenOut.uwOldTrig = 0;
    pwm_stGenOut.uwNewTrig = 0;
    pwm_stGenOut.uwSampleArea = IgnoreNone;
    pwm_stGenOut.uwRDSONTrig = 108;
    pwm_stGenOut.uwSigRTrig = HW_HHHPWM_PERIOD;
}

/************************************************************************
 Function: pwm_voGenCoef;
 Description: pwm generation coefficient initial;
 Call by: functions in main loop;
 Input Variables: PWM_COF_IN;
 Output/Return Variables: PWM_CALC_COF;
 Subroutine Call: N/A;
 Reference: N/A;
************************************************************************/
void pwm_voGenCoef(PWM_COF_IN *in, PWM_CALC_COF *coef)
{
    if (in->uwPWMDutyMax > 1000)
    {
        in->uwPWMDutyMax = 1000;
    }
    else if (in->uwPWMDutyMax == 0)
    {
        in->uwPWMDutyMax = 1;
    }

    if (in->uwPWM7To5Duty > 1000)
    {
        in->uwPWM7To5Duty = 1000;
    }
    else if (in->uwPWM7To5Duty == 0)
    {
        in->uwPWM7To5Duty = 1;
    }

    if (in->uwOvmNo > 2)
    {
        in->uwOvmNo = 2;
    }

    if (in->uwPWMPd > 31250)
    {
        in->uwPWMPd = 31250;
    }
    else if (in->uwPWMPd < 4)
    {
        in->uwPWMPd = 4;
    }
    pwm_pvt_sw1st_Cur_Smpl_Ct = cp_stControlPara.swPWM1STSampleCnt;                // 采样点1：超前PWM2上升沿43个TIMER计数，实际时间为：43/4500*62.5=0.6us
    pwm_pvt_sw2nd_Cur_Smpl_Ct = cp_stControlPara.swPWM2NDSampleCnt;                // 采样点2：超前PWM2上升沿280个TIMER计数，实际时间为：43/4500*62.5=3.88us
    pwm_pvt_swMin_Cur_Smpl_Ct = cp_stControlPara.swPWM1STSampleCnt + cp_stControlPara.swPWM2NDSampleCnt;             // 采样点1+采样点2计数
    pwm_pvt_swMin_Double_Cur_Smpl_Pu = ((SLONG)pwm_pvt_swMin_Cur_Smpl_Ct<<15)/HW_PWM_PERIOD;//Q14  最小预留采样时间

    coef->uwOvmNo = in->uwOvmNo;
    coef->uwPWMPd = in->uwPWMPd;
    coef->uwHPWMPd = in->uwPWMPd >> 1;
    coef->uwHHPWMPd = in->uwPWMPd >> 2;
    coef->ulPWMPerInv = (((ULONG)1 << 21) / in->uwPWMPd); // Q21, 1/PWM period
    coef->swPWMDutyMaxPu = ((SLONG)(in->uwPWMDutyMax - 3) << 14) / 1000;   // Q14
    coef->swPWM7To5DutyPu =((SLONG)in->uwPWM7To5Duty << 14) / 1000;       // Q14
   // coef->swPWM7To5DutyPu =  (coef->uwPWMPd - (pwm_pvt_swMin_Cur_Smpl_Ct << 2 ) - 45) * coef->ulPWMPerInv >> 7;       // Q14  //
    coef->swPWMMinSample1Pu = ((SLONG)in->uwPWMMinSample1Pu << 14) / 1000; // Q14, unit:Pu        two zero vector
    coef->swPWMMinSample2Pu = ((SLONG)in->uwPWMMinSample2Pu << 14) / 1000; // Q14, unit:Pu        (one zero vector + sample time)*2
    coef->swPWMMinSample3Pu = ((SLONG)in->uwPWMMinSample3Pu << 14) / 1000; // Q14, unit:Pu        (one Singel Resistance steady time + sample time)*2


 
    coef->uwMaxCmpCt = ((SLONG)in->uwPWMDutyMax * coef->uwHPWMPd) / 1000; // Q14
    coef->uwSampleSteadyCt = ((SLONG)in->uwSampleSteadyPu * coef->uwHPWMPd) / 1000;
    coef->uwSingelResisSampleCt = ((SLONG)in->uwSingelResisSamplePu * coef->uwHPWMPd) / 1000;
}
/************************************************************************
 Function: pwm_voGen;
 Description: pwm generation;
 Call by: functions in TBC;
 Input Variables: PWM_GEN_IN, PWM_CALC_COF;
 Output/Return Variables: PWM_GEN_OUT;
 Subroutine Call: N/A;
 Reference: N/A;
************************************************************************/
void pwm_voGen(PWM_GEN_IN *in, PWM_CALC_COF *coef, PWM_GEN_OUT *out)
{
    SLONG slL1, slL2, slL3;
    SLONG slKsvpwm;
    SLONG slX, slY, slZ;
    SWORD swT1, swT2;
    SWORD swOvmT1, swOvmT2;
    UWORD uwSector;
    SWORD swUaPu, swUbPu, swUcPu;
    SWORD swPWMPRD1, swPWMPRD2, swPWMPRD3;
    //    SWORD swPWMPRD11,swPWMPRD21,swPWMPRD31,swPWMPRD12,swPWMPRD22,swPWMPRD32;
    SWORD tmp_swPeriodA, tmp_swPeriodB, tmp_swPeriodC;
    /*==============================================================================
                       Sector Determination
        L1 = Ubeta
        L2 = sqrt(3)/2 * Ualfa - 1/2 * Ubeta
        L3 = -sqrt(3)/2 * Ualfa - 1/2 * Ubeta
    ==============================================================================*/
    slL1 = in->swUbetaPu + 1;                                          // Q14
    slL2 = ((in->swUalphaPu * PWM_SQRT3 >> 14) - in->swUbetaPu) >> 1;  // Q14
    slL3 = (-(in->swUalphaPu * PWM_SQRT3 >> 14) - in->swUbetaPu) >> 1; // Q14

    uwSector = 0;
    if (slL1 > 0)
    {
        uwSector += 1;
    }
    if (slL2 > 0)
    {
        uwSector += 2;
    }
    if (slL3 > 0)
    {
        uwSector += 4;
    }
    /*======================================================================
        Base Voltage Vector Period(t1/t2) calculation according to sector
        X = 2/sqrt(3)*Ts*slv1
        Y = -2/sqrt(3)*Ts*slv3
        Z = -2/sqrt(3)*Ts*slv2
    =======================================================================*/
    if (in->uwVdcPu < 10)
    {
        in->uwVdcPu = 10;
    }

    slKsvpwm = (PWM_SQRT3 << 15) / in->uwVdcPu; // Q15=Q14+Q15-Q14
    slX = slKsvpwm * (slL1 - 1) >> 15;          // Q14
    slY = -slKsvpwm * slL3 >> 15;               // Q14
    slZ = -slKsvpwm * slL2 >> 15;               // Q14
    switch (uwSector)
    {
    case 3:
        swT1 = -slZ; // Q14, t1
        swT2 = slX;  // Q14, t2
        break;
    case 1:
        swT1 = slZ; // Q14, t1
        swT2 = slY; // Q14, t2
        break;
    case 5:
        swT1 = slX;  // Q14, t1
        swT2 = -slY; // Q14, t2
        break;
    case 4:
        swT1 = -slX; // Q14, t1
        swT2 = slZ;  // Q14, t2
        break;
    case 6:
        swT1 = -slY; // Q14, t1
        swT2 = -slZ; // Q14, t2
        break;
    case 2:
        swT1 = slY;  // Q14, t1
        swT2 = -slX; // Q14, t2
        break;
    default:
        swT1 = 0;
        swT2 = 0;
        break;
    }
    /*================================================================
                           Over voltage modulation
    ================================================================*/
    switch (coef->uwOvmNo)
    {
    case 0:
        /* SVPWM over modulation: min phase error */
        if ((swT1 + swT2) > coef->swPWMDutyMaxPu)
        {
            swOvmT1 = (SLONG)swT1 * coef->swPWMDutyMaxPu / (swT1 + swT2); // Q14=Q14+Q14-Q14
            swOvmT2 = coef->swPWMDutyMaxPu - swOvmT1;
            out->blOvmFlag = TRUE;
        }
        else
        {
            swOvmT1 = swT1;
            swOvmT2 = swT2;
            out->blOvmFlag = FALSE;
        }
        break;
    case 1:
        /* SVPWM over modulation: min amplitude error */
        if ((swT1 + swT2) > coef->swPWMDutyMaxPu)
        {
            swOvmT1 = swT1 - ((swT1 + swT2 - coef->swPWMDutyMaxPu) >> 1);
            swOvmT2 = swT2 - ((swT1 + swT2 - coef->swPWMDutyMaxPu) >> 1);
            if (swOvmT1 < 0)
            {
                swOvmT1 = 0;
                swOvmT2 = coef->swPWMDutyMaxPu;
            }
            if (swOvmT2 < 0)
            {
                swOvmT2 = 0;
                swOvmT1 = coef->swPWMDutyMaxPu;
            }
            out->blOvmFlag = TRUE;
        }
        else
        {
            swOvmT1 = swT1;
            swOvmT2 = swT2;
            out->blOvmFlag = FALSE;
        }
        break;
    case 2:
        /* SVPWM over modulation: amplitude and phase optimum */
        if ((swT1 + swT2) > coef->swPWMDutyMaxPu)
        {
            if (swT1 > swT2)
            {
                if (swT1 > coef->swPWMDutyMaxPu)
                {
                    swOvmT1 = coef->swPWMDutyMaxPu;
                }
                else
                {
                    swOvmT1 = swT1;
                }
                swOvmT2 = coef->swPWMDutyMaxPu - swOvmT1;
            }
            else
            {
                if (swT2 > coef->swPWMDutyMaxPu)
                {
                    swOvmT2 = coef->swPWMDutyMaxPu;
                }
                else
                {
                    swOvmT2 = swT2;
                }
                swOvmT1 = coef->swPWMDutyMaxPu - swOvmT2;
            }
            out->blOvmFlag = TRUE;
        }
        else
        {
            swOvmT1 = swT1;
            swOvmT2 = swT2;
            out->blOvmFlag = FALSE;
        }
        break;
    default:
        /* SVPWM over modulation: amplitude and phase optimum */
        if ((swT1 + swT2) > coef->swPWMDutyMaxPu)
        {
            if (swT1 > swT2)
            {
                if (swT1 > coef->swPWMDutyMaxPu)
                {
                    swOvmT1 = coef->swPWMDutyMaxPu;
                }
                else
                {
                    swOvmT1 = swT1;
                }
                swOvmT2 = coef->swPWMDutyMaxPu - swOvmT1;
            }
            else
            {
                if (swT2 > coef->swPWMDutyMaxPu)
                {
                    swOvmT2 = coef->swPWMDutyMaxPu;
                }
                else
                {
                    swOvmT2 = swT2;
                }
                swOvmT1 = coef->swPWMDutyMaxPu - swOvmT2;
            }
            out->blOvmFlag = TRUE;
        }
        else
        {
            swOvmT1 = swT1;
            swOvmT2 = swT2;
            out->blOvmFlag = FALSE;
        }
        break;
    }

//    if(cp_stFlg.CurrentSampleModelSelect == SINGLERESISITANCE)
//    {
//        SWORD swPWMPRD11=0;
//        SWORD swPWMPRD21=0;
//        SWORD swPWMPRD31=0;
//        SWORD swPWMPRD12=0;
//        SWORD swPWMPRD22=0;
//        SWORD swPWMPRD32=0;
//                                    
//        /*1/4 of zero vector in the middle,and others apart in the beginning and ending*/
//        swPWMPRD1 = (((SLONG)16384  + swOvmT1 + swOvmT2) * coef->uwPWMPd) >> 16; // Q14
//        swPWMPRD2 = (((SLONG)16384  + swOvmT1 - swOvmT2) * coef->uwPWMPd) >> 16;
//        swPWMPRD3 = (((SLONG)16384 - swOvmT1 - swOvmT2) * coef->uwPWMPd) >> 16;
//        swPWMPRD11 = swPWMPRD1;
//        swPWMPRD21 = swPWMPRD2;
//        swPWMPRD31 = swPWMPRD3;
//        swPWMPRD12 = swPWMPRD1;
//        swPWMPRD22 = swPWMPRD2;
//        swPWMPRD32 = swPWMPRD3;
//        /* comparision value correction when two vectors are both too short*/
//
//        if ((swOvmT1 + swOvmT2) < (pwm_pvt_swMin_Double_Cur_Smpl_Pu << 1))
//        {
//            /*if t1 is too short, move the last comparision value to left*/
//            if ((swOvmT1 - pwm_pvt_swMin_Double_Cur_Smpl_Pu) < 0)
//            {
//                swPWMPRD31 = swPWMPRD2 - pwm_pvt_swMin_Cur_Smpl_Ct;
//                swPWMPRD32 = (swPWMPRD3 << 1) - swPWMPRD31;
//            }
//            /*if t2 is too short, move the first comparision value to right*/
//            if ((swOvmT2 - pwm_pvt_swMin_Double_Cur_Smpl_Pu) < 0)
//            {               
//                swPWMPRD21 = swPWMPRD1 - pwm_pvt_swMin_Cur_Smpl_Ct;
//                swPWMPRD22 = (swPWMPRD2 << 1) - swPWMPRD21;
//                swPWMPRD31 = swPWMPRD1 - (pwm_pvt_swMin_Cur_Smpl_Ct << 1);
//                swPWMPRD32 = (swPWMPRD3 << 1) - swPWMPRD31;
//            }
//        }
//        else
//        {
//               /*if t2 is too short and t1 is long enough for current sampling*/
//              if ((swOvmT2 - pwm_pvt_swMin_Double_Cur_Smpl_Pu) < 0)
//              {
//                /*if duty ratio is big enought, SEVEN_SEGEMNT change to five_SEGEMNT */
//                if((coef->uwHPWMPd + swPWMPRD1 - 2 * swPWMPRD2) <= pwm_pvt_swMin_Cur_Smpl_Ct)
//                {
//                    swPWMPRD1 = (((SLONG)swOvmT1 + swOvmT2) * coef->uwPWMPd) >> 15;
//                    swPWMPRD2 = ((SLONG)swOvmT1 * coef->uwPWMPd) >> 15;
//                    swPWMPRD3 = 0;
//                    if((coef->uwHPWMPd + swPWMPRD1 - 2 * swPWMPRD2) <= pwm_pvt_swMin_Cur_Smpl_Ct)
//                    {
//                        swPWMPRD11 = coef->uwHPWMPd;
//                        swPWMPRD12 = (swPWMPRD1 << 1) - swPWMPRD11;
//                        swPWMPRD31 = swPWMPRD3;
//                        swPWMPRD32 = swPWMPRD3;
//                        swPWMPRD22 = coef->uwHPWMPd;
//                        swPWMPRD21 = (swPWMPRD2 << 1) - swPWMPRD22;
//                    }
//                    else 
//                    {
//                        swPWMPRD11 = swPWMPRD1;
//                        swPWMPRD12 = swPWMPRD1;
//                        swPWMPRD21 = swPWMPRD1 - pwm_pvt_swMin_Cur_Smpl_Ct;
//                        swPWMPRD22 = (swPWMPRD2 << 1) - swPWMPRD21;
//                        swPWMPRD31 = swPWMPRD3;
//                        swPWMPRD32 = swPWMPRD3;
//                    }
//                }
//                else 
//                {
//                    swPWMPRD21 = swPWMPRD1 - pwm_pvt_swMin_Cur_Smpl_Ct;
//                    swPWMPRD22 = (swPWMPRD2 << 1) - swPWMPRD21;
//                }
//            }
//            /*if t1 is too short and t1 is long enough for current sampling*/
//            if ((swOvmT1 - pwm_pvt_swMin_Double_Cur_Smpl_Pu) < 0)
//            {
//                /*if duty ratio is big enought, SEVEN_SEGEMNT change to five_SEGEMNT */
//                if((2 * swPWMPRD2 - swPWMPRD3) <= pwm_pvt_swMin_Cur_Smpl_Ct)
//                {
//                    swPWMPRD1 = coef->uwHPWMPd;
//                    swPWMPRD2 = (((SLONG)16384 - swOvmT2) * coef->uwPWMPd) >> 15;
//                    swPWMPRD3 = (((SLONG)16384 - swOvmT1 - swOvmT2) * coef->uwPWMPd) >> 15;
//                    if ((2 * swPWMPRD2 - swPWMPRD3) <= pwm_pvt_swMin_Cur_Smpl_Ct)
//                    {
//                        swPWMPRD11 = swPWMPRD1;
//                        swPWMPRD12 = swPWMPRD1;
//                        swPWMPRD22 = 0;
//                        swPWMPRD21 = (swPWMPRD2 << 1) - swPWMPRD22;
//                        swPWMPRD31 = 0;
//                        swPWMPRD32 = (swPWMPRD3 << 1) - swPWMPRD31;
//                    }
//                    else
//                    {
//                        swPWMPRD11 = swPWMPRD1;
//                        swPWMPRD12 = swPWMPRD1;
//                        swPWMPRD21 = swPWMPRD3 + pwm_pvt_swMin_Cur_Smpl_Ct;
//                        swPWMPRD22 = (swPWMPRD2 << 1) - swPWMPRD21;
//                        swPWMPRD31 = swPWMPRD3;
//                        swPWMPRD32 = swPWMPRD3;
//                    }
//                }
//                else
//                {
//                    swPWMPRD21 = swPWMPRD3 + pwm_pvt_swMin_Cur_Smpl_Ct;
//                    swPWMPRD22 = (swPWMPRD2 << 1) - swPWMPRD21;
//                } 
//            }
//            else
//            {}
//        }
//        out->uwOldTrig = out->uwNewTrig;
//        out->uwNewTrig = swPWMPRD21;
//        switch (uwSector)
//        {
//        case 3:
//            out->uwNewTIM1COMPR[0] = swPWMPRD31;
//            out->uwNewTIM1COMPR[1] = swPWMPRD21;
//            out->uwNewTIM1COMPR[2] = swPWMPRD11;
//            out->uwNewTIM1COMPR[3] = swPWMPRD32;
//            out->uwNewTIM1COMPR[4] = swPWMPRD22;
//            out->uwNewTIM1COMPR[5] = swPWMPRD12;
//            out->uwFirstTrigCOMPR = swPWMPRD21 - pwm_pvt_sw1st_Cur_Smpl_Ct;
//            out->uwSecondTrigCOMPR = swPWMPRD21 + pwm_pvt_sw2nd_Cur_Smpl_Ct;
//            break;
//        case 1:
//            out->uwNewTIM1COMPR[0] = swPWMPRD21;
//            out->uwNewTIM1COMPR[1] = swPWMPRD31;
//            out->uwNewTIM1COMPR[2] = swPWMPRD11;
//            out->uwNewTIM1COMPR[3] = swPWMPRD22;
//            out->uwNewTIM1COMPR[4] = swPWMPRD32;
//            out->uwNewTIM1COMPR[5] = swPWMPRD12;
//            out->uwFirstTrigCOMPR = swPWMPRD21 - pwm_pvt_sw1st_Cur_Smpl_Ct;
//            out->uwSecondTrigCOMPR = swPWMPRD21 + pwm_pvt_sw2nd_Cur_Smpl_Ct;
//            break;
//        case 5:
//            out->uwNewTIM1COMPR[0] = swPWMPRD11;
//            out->uwNewTIM1COMPR[1] = swPWMPRD31;
//            out->uwNewTIM1COMPR[2] = swPWMPRD21;
//            out->uwNewTIM1COMPR[3] = swPWMPRD12;
//            out->uwNewTIM1COMPR[4] = swPWMPRD32;
//            out->uwNewTIM1COMPR[5] = swPWMPRD22;
//            out->uwFirstTrigCOMPR = swPWMPRD21 - pwm_pvt_sw1st_Cur_Smpl_Ct;
//            out->uwSecondTrigCOMPR = swPWMPRD21 + pwm_pvt_sw2nd_Cur_Smpl_Ct;
//            break;
//        case 4:
//            out->uwNewTIM1COMPR[0] = swPWMPRD11;
//            out->uwNewTIM1COMPR[1] = swPWMPRD21;
//            out->uwNewTIM1COMPR[2] = swPWMPRD31;
//            out->uwNewTIM1COMPR[3] = swPWMPRD12;
//            out->uwNewTIM1COMPR[4] = swPWMPRD22;
//            out->uwNewTIM1COMPR[5] = swPWMPRD32;
//            out->uwFirstTrigCOMPR = swPWMPRD21 - pwm_pvt_sw1st_Cur_Smpl_Ct;
//            out->uwSecondTrigCOMPR = swPWMPRD21 + pwm_pvt_sw2nd_Cur_Smpl_Ct;
//            break;
//        case 6:
//            out->uwNewTIM1COMPR[0] = swPWMPRD21;
//            out->uwNewTIM1COMPR[1] = swPWMPRD11;
//            out->uwNewTIM1COMPR[2] = swPWMPRD31;
//            out->uwNewTIM1COMPR[3] = swPWMPRD22;
//            out->uwNewTIM1COMPR[4] = swPWMPRD12;
//            out->uwNewTIM1COMPR[5] = swPWMPRD32;
//            out->uwFirstTrigCOMPR = swPWMPRD21 - pwm_pvt_sw1st_Cur_Smpl_Ct;
//            out->uwSecondTrigCOMPR = swPWMPRD21 + pwm_pvt_sw2nd_Cur_Smpl_Ct;
//            break;
//        case 2:
//            out->uwNewTIM1COMPR[0] = swPWMPRD31;
//            out->uwNewTIM1COMPR[1] = swPWMPRD11;
//            out->uwNewTIM1COMPR[2] = swPWMPRD21;
//            out->uwNewTIM1COMPR[3] = swPWMPRD32;
//            out->uwNewTIM1COMPR[4] = swPWMPRD12;
//            out->uwNewTIM1COMPR[5] = swPWMPRD22;
//            out->uwFirstTrigCOMPR = swPWMPRD21 - pwm_pvt_sw1st_Cur_Smpl_Ct;
//            out->uwSecondTrigCOMPR = swPWMPRD21 + pwm_pvt_sw2nd_Cur_Smpl_Ct;
//            break;
//        default:
//            out->uwNewTIM1COMPR[0] = coef->uwHHPWMPd;
//            out->uwNewTIM1COMPR[1] = coef->uwHHPWMPd;
//            out->uwNewTIM1COMPR[2] = coef->uwHHPWMPd;
//            out->uwNewTIM1COMPR[3] = coef->uwHHPWMPd;
//            out->uwNewTIM1COMPR[4] = coef->uwHHPWMPd;
//            out->uwNewTIM1COMPR[5] = coef->uwHHPWMPd;
//            out->uwFirstTrigCOMPR = coef->uwHHPWMPd >> 1;
//            out->uwSecondTrigCOMPR = coef->uwHPWMPd - coef->uwHHPWMPd >> 1;
//            break;
//        }
//        out->uwNewSectorNum = uwSector;
//        out->uwPWMNewSectorNum = out->uwNewSectorNum;
//
//        tmp_swPeriodA = coef->uwPWMPd - out->uwNewTIM1COMPR[0] - out->uwNewTIM1COMPR[3];
//        tmp_swPeriodB = coef->uwPWMPd - out->uwNewTIM1COMPR[1] - out->uwNewTIM1COMPR[4];
//        tmp_swPeriodC = coef->uwPWMPd - out->uwNewTIM1COMPR[2] - out->uwNewTIM1COMPR[5];
//
//        swUaPu = ((((SLONG)tmp_swPeriodA * coef->ulPWMPerInv) >> 5) * in->uwVdcPu) >> 16; // Q21-Q5+Q14-Q16=Q14
//        swUbPu = ((((SLONG)tmp_swPeriodB * coef->ulPWMPerInv) >> 5) * in->uwVdcPu) >> 16; // Q21-Q5+Q14-Q16=Q14
//        swUcPu = ((((SLONG)tmp_swPeriodC * coef->ulPWMPerInv) >> 5) * in->uwVdcPu) >> 16; // Q21-Q5+Q14-Q16=Q14
//
//        out->swUalphaPu = (swUaPu + swUaPu - swUbPu - swUcPu) * PWM_1DIV3 >> 14; // Q14=Q14+Q14-Q14
//        out->swUbetaPu = (swUbPu - swUcPu) * PWM_SQRT3_INV >> 14;                // Q14=Q14+Q14-Q14
//
//    }
//    else if(cp_stFlg.CurrentSampleModelSelect == RDSON)
//    {
//        /*================================================================
//                            Calculate compare value
//        ================================================================*/
//        if ((swOvmT1 + swOvmT2) > coef->swPWM7To5DutyPu) /* Five SVPWM */
//        {
//            swPWMPRD1 = coef->uwHPWMPd;
//            swPWMPRD2 = ((ULONG)(16384 - swOvmT2) * coef->uwHPWMPd) >> 14;
//            swPWMPRD3 = ((ULONG)(16384 - swOvmT1 - swOvmT2) * coef->uwHPWMPd) >> 14;
//        }
//        else /* Seven SVPWM */
//        {
//            swPWMPRD1 = ((ULONG)(16384 + swOvmT1 + swOvmT2) * coef->uwHHPWMPd) >> 14;
//            swPWMPRD2 = ((ULONG)(16384 + swOvmT1 - swOvmT2) * coef->uwHHPWMPd) >> 14;
//            swPWMPRD3 = ((ULONG)(16384 - swOvmT1 - swOvmT2) * coef->uwHHPWMPd) >> 14;
//        }
//
//        switch (uwSector)
//        {
//        case 3:
//            out->uwNewTIM1COMPR[0] = swPWMPRD3;
//            out->uwNewTIM1COMPR[1] = swPWMPRD2;
//            out->uwNewTIM1COMPR[2] = swPWMPRD1;
//            out->uwNewTIM1COMPR[3] = swPWMPRD3;
//            out->uwNewTIM1COMPR[4] = swPWMPRD2;
//            out->uwNewTIM1COMPR[5] = swPWMPRD1;
//
//            break;
//        case 1:
//            out->uwNewTIM1COMPR[0] = swPWMPRD2;
//            out->uwNewTIM1COMPR[1] = swPWMPRD3;
//            out->uwNewTIM1COMPR[2] = swPWMPRD1;
//            out->uwNewTIM1COMPR[3] = swPWMPRD2;
//            out->uwNewTIM1COMPR[4] = swPWMPRD3;
//            out->uwNewTIM1COMPR[5] = swPWMPRD1;
//
//            break;
//        case 5:
//            out->uwNewTIM1COMPR[0] = swPWMPRD1;
//            out->uwNewTIM1COMPR[1] = swPWMPRD3;
//            out->uwNewTIM1COMPR[2] = swPWMPRD2;
//            out->uwNewTIM1COMPR[3] = swPWMPRD1;
//            out->uwNewTIM1COMPR[4] = swPWMPRD3;
//            out->uwNewTIM1COMPR[5] = swPWMPRD2;
//
//            break;
//        case 4:
//            out->uwNewTIM1COMPR[0] = swPWMPRD1;
//            out->uwNewTIM1COMPR[1] = swPWMPRD2;
//            out->uwNewTIM1COMPR[2] = swPWMPRD3;
//            out->uwNewTIM1COMPR[3] = swPWMPRD1;
//            out->uwNewTIM1COMPR[4] = swPWMPRD2;
//            out->uwNewTIM1COMPR[5] = swPWMPRD3;
//
//            break;
//        case 6:
//            out->uwNewTIM1COMPR[0] = swPWMPRD2;
//            out->uwNewTIM1COMPR[1] = swPWMPRD1;
//            out->uwNewTIM1COMPR[2] = swPWMPRD3;
//            out->uwNewTIM1COMPR[3] = swPWMPRD2;
//            out->uwNewTIM1COMPR[4] = swPWMPRD1;
//            out->uwNewTIM1COMPR[5] = swPWMPRD3;
//
//            break;
//        case 2:
//            out->uwNewTIM1COMPR[0] = swPWMPRD3;
//            out->uwNewTIM1COMPR[1] = swPWMPRD1;
//            out->uwNewTIM1COMPR[2] = swPWMPRD2;
//            out->uwNewTIM1COMPR[3] = swPWMPRD3;
//            out->uwNewTIM1COMPR[4] = swPWMPRD1;
//            out->uwNewTIM1COMPR[5] = swPWMPRD2;
//
//            break;
//        default:
//            out->uwNewTIM1COMPR[0] = coef->uwHHPWMPd;
//            out->uwNewTIM1COMPR[1] = coef->uwHHPWMPd;
//            out->uwNewTIM1COMPR[2] = coef->uwHHPWMPd;
//            out->uwNewTIM1COMPR[3] = coef->uwHHPWMPd;
//            out->uwNewTIM1COMPR[4] = coef->uwHHPWMPd;
//            out->uwNewTIM1COMPR[5] = coef->uwHHPWMPd;
//
//            break;
//        }
//
//        /* Calculate actual output voltage */
//        out->uwNewSectorNum = uwSector;
//        out->uwPWMNewSectorNum = out->uwNewSectorNum;
//
//        tmp_swPeriodA = coef->uwPWMPd - out->uwNewTIM1COMPR[0] - out->uwNewTIM1COMPR[3];
//        tmp_swPeriodB = coef->uwPWMPd - out->uwNewTIM1COMPR[1] - out->uwNewTIM1COMPR[4];
//        tmp_swPeriodC = coef->uwPWMPd - out->uwNewTIM1COMPR[2] - out->uwNewTIM1COMPR[5];
//
//        swUaPu = ((((SLONG)tmp_swPeriodA * coef->ulPWMPerInv) >> 5) * in->uwVdcPu) >> 16; // Q21-Q5+Q14-Q16=Q14
//        swUbPu = ((((SLONG)tmp_swPeriodB * coef->ulPWMPerInv) >> 5) * in->uwVdcPu) >> 16; // Q21-Q5+Q14-Q16=Q14
//        swUcPu = ((((SLONG)tmp_swPeriodC * coef->ulPWMPerInv) >> 5) * in->uwVdcPu) >> 16; // Q21-Q5+Q14-Q16=Q14
//
//        out->swUalphaPu = (swUaPu + swUaPu - swUbPu - swUcPu) * PWM_1DIV3 >> 14; // Q14=Q14+Q14-Q14
//        out->swUbetaPu = (swUbPu - swUcPu) * PWM_SQRT3_INV >> 14;                // Q14=Q14+Q14-Q14
//
//        if ((16384 - swOvmT1 - swOvmT2) > coef->swPWMMinSample1Pu)
//        {
//            out->uwSampleArea = IgnoreNone;
//            out->uwRDSONTrig = 108;
//        }
//        else
//        {
//            if (swOvmT1 > coef->swPWMMinSample1Pu)
//            {
//                switch (uwSector)
//                {
//                case 3:
//                    out->uwSampleArea = IgnoreA;
//                    break;
//                case 1:
//                    out->uwSampleArea = IgnoreB;
//                    break;
//                case 5:
//                    out->uwSampleArea = IgnoreB;
//                    break;
//                case 4:
//                    out->uwSampleArea = IgnoreC;
//                    break;
//                case 6:
//                    out->uwSampleArea = IgnoreC;
//                    break;
//                case 2:
//                    out->uwSampleArea = IgnoreA;
//                    break;
//                default:
//                    out->uwSampleArea = IgnoreNone;
//                    break;
//                }
//                out->uwRDSONTrig = swPWMPRD3 + coef->uwSampleSteadyCt;
//            }
//            else
//            {
//                switch (uwSector)
//                {
//                case 3:
//                    out->uwSampleArea = IgnoreAB;
//                    break;
//                case 1:
//                    out->uwSampleArea = IgnoreAB;
//                    break;
//                case 5:
//                    out->uwSampleArea = IgnoreBC;
//                    break;
//                case 4:
//                    out->uwSampleArea = IgnoreBC;
//                    break;
//                case 6:
//                    out->uwSampleArea = IgnoreAC;
//                    break;
//                case 2:
//                    out->uwSampleArea = IgnoreAC;
//                    break;
//                default:
//                    out->uwSampleArea = IgnoreNone;
//                    break;
//                }
//                out->uwRDSONTrig = swPWMPRD2 + coef->uwSampleSteadyCt;
//            }
//        }
//    }
//    else if(cp_stFlg.CurrentSampleModelSelect == COMBINATION)
    #if(SampleModelSelect == COMBINATION)
     
         /*================================================================
                            Calculate compare value
        ================================================================*/
        if ((swOvmT1 + swOvmT2) > coef->swPWM7To5DutyPu) /* Five SVPWM */
        {
            swPWMPRD1 = coef->uwHPWMPd;
            swPWMPRD2 = ((ULONG)(16384 - swOvmT2) * coef->uwHPWMPd) >> 14;
            swPWMPRD3 = ((ULONG)(16384 - swOvmT1 - swOvmT2) * coef->uwHPWMPd) >> 14;
        }
        else /* Seven SVPWM */
        {
            swPWMPRD1 = ((ULONG)(16384 + swOvmT1 + swOvmT2) * coef->uwHHPWMPd) >> 14;//TC
            swPWMPRD2 = ((ULONG)(16384 + swOvmT1 - swOvmT2) * coef->uwHHPWMPd) >> 14;//TB
            swPWMPRD3 = ((ULONG)(16384 - swOvmT1 - swOvmT2) * coef->uwHHPWMPd) >> 14;//TA
        }

        if (swOvmT2 > coef->swPWMMinSample3Pu) //6us
        {
            if(swPWMPRD2>( coef->uwSingelResisSampleCt*20))
            {
            out->blSampleCalibFlag = TRUE;
          out->uwSigRTrig = swPWMPRD2 +  (coef->uwSingelResisSampleCt +18 );

            }
        }
        //    else if(swOvmT1>coef->swPWMMinSample3Pu)
        //    {
        //      out->blSampleCalibFlag = TRUE;
        //      out->uwSigRTrig = swPWMPRD3 - coef->uwSingelResisSampleCt;
        //    }
        else
        {
            out->blSampleCalibFlag = FALSE;
            out->uwSigRTrig = coef->uwHPWMPd;
        }

        switch (uwSector)
        {
        case 3:
            out->uwNewTIM1COMPR[0] = swPWMPRD3;
            out->uwNewTIM1COMPR[1] = swPWMPRD2;
            out->uwNewTIM1COMPR[2] = swPWMPRD1;
            out->uwNewTIM1COMPR[3] = swPWMPRD3;
            out->uwNewTIM1COMPR[4] = swPWMPRD2;
            out->uwNewTIM1COMPR[5] = swPWMPRD1;
            if (out->blSampleCalibFlag == TRUE)
            {
                out->uwSingelRSampleArea =  SampleC;
            }
            else
            {
                out->uwSingelRSampleArea = SampleNone;
            }
            break;
        case 1:
            out->uwNewTIM1COMPR[0] = swPWMPRD2;
            out->uwNewTIM1COMPR[1] = swPWMPRD3;
            out->uwNewTIM1COMPR[2] = swPWMPRD1;
            out->uwNewTIM1COMPR[3] = swPWMPRD2;
            out->uwNewTIM1COMPR[4] = swPWMPRD3;
            out->uwNewTIM1COMPR[5] = swPWMPRD1;
            if (out->blSampleCalibFlag == TRUE)
            {
                out->uwSingelRSampleArea =   SampleC;
            }
            else
            {
                out->uwSingelRSampleArea = SampleNone;
            }
            break;
        case 5:
            out->uwNewTIM1COMPR[0] = swPWMPRD1;
            out->uwNewTIM1COMPR[1] = swPWMPRD3;
            out->uwNewTIM1COMPR[2] = swPWMPRD2;
            out->uwNewTIM1COMPR[3] = swPWMPRD1;
            out->uwNewTIM1COMPR[4] = swPWMPRD3;
            out->uwNewTIM1COMPR[5] = swPWMPRD2;
            if (out->blSampleCalibFlag == TRUE)
            {
                out->uwSingelRSampleArea =  SampleA;
            }
            else
            {
                out->uwSingelRSampleArea = SampleNone;
            }
            break;
        case 4:
            out->uwNewTIM1COMPR[0] = swPWMPRD1;
            out->uwNewTIM1COMPR[1] = swPWMPRD2;
            out->uwNewTIM1COMPR[2] = swPWMPRD3;
            out->uwNewTIM1COMPR[3] = swPWMPRD1;
            out->uwNewTIM1COMPR[4] = swPWMPRD2;
            out->uwNewTIM1COMPR[5] = swPWMPRD3;
            if (out->blSampleCalibFlag == TRUE)
            {
                out->uwSingelRSampleArea =   SampleA;
            }
            else
            {
                out->uwSingelRSampleArea = SampleNone;
            }
            break;
        case 6:
            out->uwNewTIM1COMPR[0] = swPWMPRD2;
            out->uwNewTIM1COMPR[1] = swPWMPRD1;
            out->uwNewTIM1COMPR[2] = swPWMPRD3;
            out->uwNewTIM1COMPR[3] = swPWMPRD2;
            out->uwNewTIM1COMPR[4] = swPWMPRD1;
            out->uwNewTIM1COMPR[5] = swPWMPRD3;
            if (out->blSampleCalibFlag == TRUE)
            {
                out->uwSingelRSampleArea =  SampleB;
            }
            else
            {
                out->uwSingelRSampleArea = SampleNone;
            }
            break;
        case 2:
            out->uwNewTIM1COMPR[0] = swPWMPRD3;
            out->uwNewTIM1COMPR[1] = swPWMPRD1;
            out->uwNewTIM1COMPR[2] = swPWMPRD2;
            out->uwNewTIM1COMPR[3] = swPWMPRD3;
            out->uwNewTIM1COMPR[4] = swPWMPRD1;
            out->uwNewTIM1COMPR[5] = swPWMPRD2;
            if (out->blSampleCalibFlag == TRUE)
            {
                out->uwSingelRSampleArea =  SampleB;
            }
            else
            {
                out->uwSingelRSampleArea = SampleNone;
            }
            break;
        default:
            out->uwNewTIM1COMPR[0] = coef->uwHHPWMPd;
            out->uwNewTIM1COMPR[1] = coef->uwHHPWMPd;
            out->uwNewTIM1COMPR[2] = coef->uwHHPWMPd;
            out->uwNewTIM1COMPR[3] = coef->uwHHPWMPd;
            out->uwNewTIM1COMPR[4] = coef->uwHHPWMPd;
            out->uwNewTIM1COMPR[5] = coef->uwHHPWMPd;
            out->uwSingelRSampleArea = SampleNone;
            break;
        }

        /* Calculate actual output voltage */
        out->uwNewSectorNum = uwSector;
        out->uwPWMNewSectorNum = out->uwNewSectorNum;

        tmp_swPeriodA = coef->uwPWMPd - out->uwNewTIM1COMPR[0] - out->uwNewTIM1COMPR[3];
        tmp_swPeriodB = coef->uwPWMPd - out->uwNewTIM1COMPR[1] - out->uwNewTIM1COMPR[4];
        tmp_swPeriodC = coef->uwPWMPd - out->uwNewTIM1COMPR[2] - out->uwNewTIM1COMPR[5];

        swUaPu = ((((SLONG)tmp_swPeriodA * coef->ulPWMPerInv) >> 5) * in->uwVdcPu) >> 16; // Q21-Q5+Q14-Q16=Q14
        swUbPu = ((((SLONG)tmp_swPeriodB * coef->ulPWMPerInv) >> 5) * in->uwVdcPu) >> 16; // Q21-Q5+Q14-Q16=Q14
        swUcPu = ((((SLONG)tmp_swPeriodC * coef->ulPWMPerInv) >> 5) * in->uwVdcPu) >> 16; // Q21-Q5+Q14-Q16=Q14

        out->swUalphaPu = (swUaPu + swUaPu - swUbPu - swUcPu) * PWM_1DIV3 >> 14; // Q14=Q14+Q14-Q14
        out->swUbetaPu = (swUbPu - swUcPu) * PWM_SQRT3_INV >> 14;                // Q14=Q14+Q14-Q14

        //    if((16384-swOvmT1-swOvmT2)>coef->swPWMMinSample1Pu)
        //    {
        //      out->uwSampleArea = IgnoreNone;
        out->uwRDSONTrig = 108;  //108
        //    }
        //    else
        //    {
        //      if(swOvmT1>coef->swPWMMinSample1Pu)
        //      {
        //        switch(uwSector)
        //        {
        //            case 3:
        //                out->uwSampleArea = IgnoreA;
        //                break;
        //            case 1:
        //                out->uwSampleArea = IgnoreB;
        //                break;
        //            case 5:
        //                out->uwSampleArea = IgnoreB;
        //                break;
        //            case 4:
        //                out->uwSampleArea = IgnoreC;
        //                break;
        //            case 6:
        //                out->uwSampleArea = IgnoreC;
        //                break;
        //            case 2:
        //                out->uwSampleArea = IgnoreA;
        //                break;
        //            default:
        //                out->uwSampleArea = IgnoreNone;
        //                break;
        //        }
        //        out->uwRDSONTrig = swPWMPRD3 + coef->uwSampleSteadyCt;
        //      }
        //      else
        //      {
        //        switch(uwSector)
        //        {
        //            case 3:
        //                out->uwSampleArea = IgnoreAB;
        //                break;
        //            case 1:
        //                out->uwSampleArea = IgnoreAB;
        //                break;
        //            case 5:
        //                out->uwSampleArea = IgnoreBC;
        //                break;
        //            case 4:
        //                out->uwSampleArea = IgnoreBC;
        //                break;
        //            case 6:
        //                out->uwSampleArea = IgnoreAC;
        //                break;
        //            case 2:
        //                out->uwSampleArea = IgnoreAC;
        //                break;
        //            default:
        //                out->uwSampleArea = IgnoreNone;
        //                break;
        //        }
        //      out->uwRDSONTrig = swPWMPRD2 + coef->uwSampleSteadyCt;
        //      }
        //    }
     
    #elif(SampleModelSelect == DOUBLERESISTANCE)    //   if(cp_stFlg.CurrentSampleModelSelect == DOUBLERESISTANCE)
    
        /*================================================================
                            Calculate compare value
        ================================================================*/
        if ((swOvmT1 + swOvmT2) > coef->swPWM7To5DutyPu) /* Five SVPWM */
        {
            swPWMPRD1 = coef->uwHPWMPd;
            swPWMPRD2 = ((ULONG)(16384 - swOvmT2) * coef->uwHPWMPd) >> 14;
            swPWMPRD3 = ((ULONG)(16384 - swOvmT1 - swOvmT2) * coef->uwHPWMPd) >> 14;
        }
        else /* Seven SVPWM */
        {
            swPWMPRD1 = ((ULONG)(16384 + swOvmT1 + swOvmT2) * coef->uwHHPWMPd) >> 14;
            swPWMPRD2 = ((ULONG)(16384 + swOvmT1 - swOvmT2) * coef->uwHHPWMPd) >> 14;
            swPWMPRD3 = ((ULONG)(16384 - swOvmT1 - swOvmT2) * coef->uwHHPWMPd) >> 14;
        }

        switch (uwSector)
        {
        case 3:
            out->uwNewTIM1COMPR[0] = swPWMPRD3;
            out->uwNewTIM1COMPR[1] = swPWMPRD2;
            out->uwNewTIM1COMPR[2] = swPWMPRD1;
            out->uwNewTIM1COMPR[3] = swPWMPRD3;
            out->uwNewTIM1COMPR[4] = swPWMPRD2;
            out->uwNewTIM1COMPR[5] = swPWMPRD1;

            break;
        case 1:
            out->uwNewTIM1COMPR[0] = swPWMPRD2;
            out->uwNewTIM1COMPR[1] = swPWMPRD3;
            out->uwNewTIM1COMPR[2] = swPWMPRD1;
            out->uwNewTIM1COMPR[3] = swPWMPRD2;
            out->uwNewTIM1COMPR[4] = swPWMPRD3;
            out->uwNewTIM1COMPR[5] = swPWMPRD1;

            break;
        case 5:
            out->uwNewTIM1COMPR[0] = swPWMPRD1;
            out->uwNewTIM1COMPR[1] = swPWMPRD3;
            out->uwNewTIM1COMPR[2] = swPWMPRD2;
            out->uwNewTIM1COMPR[3] = swPWMPRD1;
            out->uwNewTIM1COMPR[4] = swPWMPRD3;
            out->uwNewTIM1COMPR[5] = swPWMPRD2;

            break;
        case 4:
            out->uwNewTIM1COMPR[0] = swPWMPRD1;
            out->uwNewTIM1COMPR[1] = swPWMPRD2;
            out->uwNewTIM1COMPR[2] = swPWMPRD3;
            out->uwNewTIM1COMPR[3] = swPWMPRD1;
            out->uwNewTIM1COMPR[4] = swPWMPRD2;
            out->uwNewTIM1COMPR[5] = swPWMPRD3;

            break;
        case 6:
            out->uwNewTIM1COMPR[0] = swPWMPRD2;
            out->uwNewTIM1COMPR[1] = swPWMPRD1;
            out->uwNewTIM1COMPR[2] = swPWMPRD3;
            out->uwNewTIM1COMPR[3] = swPWMPRD2;
            out->uwNewTIM1COMPR[4] = swPWMPRD1;
            out->uwNewTIM1COMPR[5] = swPWMPRD3;

            break;
        case 2:
            out->uwNewTIM1COMPR[0] = swPWMPRD3;
            out->uwNewTIM1COMPR[1] = swPWMPRD1;
            out->uwNewTIM1COMPR[2] = swPWMPRD2;
            out->uwNewTIM1COMPR[3] = swPWMPRD3;
            out->uwNewTIM1COMPR[4] = swPWMPRD1;
            out->uwNewTIM1COMPR[5] = swPWMPRD2;

            break;
        default:
            out->uwNewTIM1COMPR[0] = coef->uwHHPWMPd;
            out->uwNewTIM1COMPR[1] = coef->uwHHPWMPd;
            out->uwNewTIM1COMPR[2] = coef->uwHHPWMPd;
            out->uwNewTIM1COMPR[3] = coef->uwHHPWMPd;
            out->uwNewTIM1COMPR[4] = coef->uwHHPWMPd;
            out->uwNewTIM1COMPR[5] = coef->uwHHPWMPd;

            break;
        }

        /* Calculate actual output voltage */
        out->uwNewSectorNum = uwSector;
        out->uwPWMNewSectorNum = out->uwNewSectorNum;

        tmp_swPeriodA = coef->uwPWMPd - out->uwNewTIM1COMPR[0] - out->uwNewTIM1COMPR[3];
        tmp_swPeriodB = coef->uwPWMPd - out->uwNewTIM1COMPR[1] - out->uwNewTIM1COMPR[4];
        tmp_swPeriodC = coef->uwPWMPd - out->uwNewTIM1COMPR[2] - out->uwNewTIM1COMPR[5];

        swUaPu = ((((SLONG)tmp_swPeriodA * coef->ulPWMPerInv) >> 5) * in->uwVdcPu) >> 16; // Q21-Q5+Q14-Q16=Q14
        swUbPu = ((((SLONG)tmp_swPeriodB * coef->ulPWMPerInv) >> 5) * in->uwVdcPu) >> 16; // Q21-Q5+Q14-Q16=Q14
        swUcPu = ((((SLONG)tmp_swPeriodC * coef->ulPWMPerInv) >> 5) * in->uwVdcPu) >> 16; // Q21-Q5+Q14-Q16=Q14

        out->swUalphaPu = (swUaPu + swUaPu - swUbPu - swUcPu) * PWM_1DIV3 >> 14; // Q14=Q14+Q14-Q14
        out->swUbetaPu = (swUbPu - swUcPu) * PWM_SQRT3_INV >> 14;                // Q14=Q14+Q14-Q14
#endif 

////    hw_uwPWMCmpr[0] = out->uwNewTIM1COMPR[0];
////    hw_uwPWMCmpr[1] = out->uwNewTIM1COMPR[1];
////    hw_uwPWMCmpr[2] = out->uwNewTIM1COMPR[2];
////    hw_uwPWMCmpr[3] = out->uwNewTIM1COMPR[3];
////    hw_uwPWMCmpr[4] = out->uwNewTIM1COMPR[4];
////    hw_uwPWMCmpr[5] = out->uwNewTIM1COMPR[5];
    
}

/************************************************************************
 Local Functions: N/A
************************************************************************/

/************************************************************************
 Copyright (c) 2018 Welling Motor Technology(Shanghai) Co. Ltd.
 All rights reserved.
************************************************************************/
#ifdef _PWM_C_
#undef _PWM_C_
#endif
/************************************************************************
 End of this File (EOF)!
 Do not put anything after this part!
************************************************************************/