/************************************************************************
 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_sw1stCurSmplCt = cp_stControlPara.swPWM1STSampleCnt;                // min time for ADC one channel of Current
    pwm_sw2ndCurSmplCt = cp_stControlPara.swPWM2NDSampleCnt;                // the time of second current sample trig lag the second comparator
    pwm_swMinDoubleCurSmplPu = (cp_stControlPara.swPWMMinEffVectorPu << 1); // min time of Two valid voltage vector
    pwm_swMinCurSmplCt = cp_stControlPara.swPWMMinEffVectorCnt;             // min counts of one valid voltage vector
    pwm_swMinCurSmplPu = cp_stControlPara.swPWMMinEffVectorCnt;             // min time of one valid voltage vector

    pwm_pvt_sw1st_Cur_Smpl_Ct = pwm_sw1stCurSmplCt;
    pwm_pvt_sw2nd_Cur_Smpl_Ct = pwm_sw2ndCurSmplCt;
    pwm_pvt_swMin_Double_Cur_Smpl_Pu = pwm_swMinDoubleCurSmplPu;
    pwm_pvt_swMin_Cur_Smpl_Ct = pwm_swMinCurSmplCt;
    pwm_pvt_swMin_Cur_Smpl_Pu = pwm_swMinCurSmplPu;

    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 = 129;
    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;
    }

    coef->swPWMDutyMaxPu = ((SLONG)(in->uwPWMDutyMax - 3) << 14) / 1000;   // Q14
    coef->swPWM7To5DutyPu = ((SLONG)in->uwPWM7To5Duty << 14) / 1000;       // 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->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->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;
************************************************************************/
UWORD testkjsahfjkahj,testkjsahfjkahj1;
SWORD swOvmT1, swOvmT2;
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;
    
    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 == 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;
            swPWMPRD2 = ((ULONG)(16384 + swOvmT1 - swOvmT2) * coef->uwHHPWMPd) >> 14;
            swPWMPRD3 = ((ULONG)(16384 - swOvmT1 - swOvmT2) * coef->uwHHPWMPd) >> 14;
        }

        if (swOvmT2 > coef->swPWMMinSample3Pu)
        {
            out->blSampleCalibFlag = TRUE;
            //out->uwSigRTrig = swPWMPRD2 + coef->uwSingelResisSampleCt;
            out->uwSigRTrig = swPWMPRD1 - coef->uwSingelResisSampleCt;
        }
        else
        {
            out->blSampleCalibFlag = FALSE;
            out->uwSigRTrig = HW_HHHPWM_PERIOD;
        }

        out->uwSingelRSampleAreaLast = out->uwSingelRSampleArea;
        if(1)//hw_blChrgOvrFlg == TRUE)
        {
        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 = 129;
        //    }
        //    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 == 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 * 3 + swOvmT1 + swOvmT2) * coef->uwPWMPd) >> 17; // Q14
        swPWMPRD2 = (((SLONG)16384 * 3 + swOvmT1 - swOvmT2 * 3) * coef->uwPWMPd) >> 17;
        swPWMPRD3 = (((SLONG)16384 - swOvmT1 - swOvmT2) * 3 * coef->uwPWMPd) >> 17;
        swPWMPRD11 = swPWMPRD1;
        swPWMPRD21 = swPWMPRD2;
        swPWMPRD31 = swPWMPRD3;
        swPWMPRD12 = swPWMPRD1;
        swPWMPRD22 = swPWMPRD2;
        swPWMPRD32 = swPWMPRD3;
        /* comparision value correction when two vectors are both too short*/
      testkjsahfjkahj1=0;
      testkjsahfjkahj=0;
        if ((swOvmT1 + swOvmT2) < (pwm_pvt_swMin_Double_Cur_Smpl_Pu << 1))
        {

            if ((swOvmT1 - pwm_pvt_swMin_Double_Cur_Smpl_Pu) < 0)
            {
                swPWMPRD31 = swPWMPRD2 - pwm_pvt_swMin_Cur_Smpl_Ct;
                swPWMPRD32 = (swPWMPRD3 << 1) - swPWMPRD31;
                testkjsahfjkahj1=1;
                
            }
            if ((swOvmT2 - pwm_pvt_swMin_Double_Cur_Smpl_Pu) < 0)
            {
                swPWMPRD11 = swPWMPRD2 + pwm_pvt_swMin_Cur_Smpl_Ct;
                swPWMPRD12 = (swPWMPRD1 << 1) - swPWMPRD11;
                testkjsahfjkahj=2;
            }
        }
        else
        {

            if ((swOvmT2 - pwm_pvt_swMin_Double_Cur_Smpl_Pu) < 0)
            {

                if (((coef->uwHPWMPd + swPWMPRD1 - 2 * swPWMPRD2) <= pwm_pvt_swMin_Cur_Smpl_Ct) && ((swOvmT1 + swOvmT2) > coef->swPWM7To5DutyPu))
                {

                    swPWMPRD1 = (((SLONG)swOvmT1 + swOvmT2) * coef->uwPWMPd) >> 15;
                    swPWMPRD2 = ((SLONG)swOvmT1 * coef->uwPWMPd) >> 15;
                    swPWMPRD3 = 0;
                    swPWMPRD11 = coef->uwHPWMPd;
                    swPWMPRD12 = (swPWMPRD1 << 1) - swPWMPRD11;
                    swPWMPRD31 = swPWMPRD3;
                    swPWMPRD32 = swPWMPRD3;
                    swPWMPRD22 = coef->uwHPWMPd;
                    swPWMPRD21 = (swPWMPRD2 << 1) - swPWMPRD22;
                    testkjsahfjkahj=3;
                }
                else
                {
                    swPWMPRD21 = swPWMPRD1 - pwm_pvt_swMin_Cur_Smpl_Ct;
                    swPWMPRD22 = (swPWMPRD2 << 1) - swPWMPRD21;
                    testkjsahfjkahj=4;
                    
                }
            }
            else if ((swOvmT1 - pwm_pvt_swMin_Double_Cur_Smpl_Pu) < 0)
            {
                if (((2 * swPWMPRD2 - swPWMPRD3) <= pwm_pvt_swMin_Cur_Smpl_Ct) && ((swOvmT1 + swOvmT2) > coef->swPWM7To5DutyPu))
                {

                    swPWMPRD1 = coef->uwHPWMPd;
                    swPWMPRD2 = (((SLONG)16384 - swOvmT2) * coef->uwPWMPd) >> 15;
                    swPWMPRD3 = (((SLONG)16384 - swOvmT1 - swOvmT2) * coef->uwPWMPd) >> 15;
                    swPWMPRD11 = swPWMPRD1;
                    swPWMPRD12 = swPWMPRD1;
                    swPWMPRD22 = 0;
                    swPWMPRD21 = (swPWMPRD2 << 1) - swPWMPRD22;
                    swPWMPRD31 = 0;
                    swPWMPRD32 = (swPWMPRD3 << 1) - swPWMPRD31;
                    testkjsahfjkahj=5;
                }
                else
                {
                    swPWMPRD21 = swPWMPRD3 + pwm_pvt_swMin_Cur_Smpl_Ct;
                    swPWMPRD22 = (swPWMPRD2 << 1) - swPWMPRD21;
                    testkjsahfjkahj=6;
                }
            }
            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 = 129;
        }
        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
    {}  

//    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!
************************************************************************/