FOC的PI调节和SVPWM

最新推荐文章于 2024-10-13 16:55:28 发布
吃西瓜长个儿
最新推荐文章于 2024-10-13 16:55:28 发布
阅读量199
点赞数 2
文章标签：算法
本文链接：https://blog.csdn.net/shendingposb/article/details/141891386
版权
void PI_Process(void)                   //一阶滤波函数
{
    ialfa=ia;
    ibeta=_IQmpy(ia,_IQ(0.57735026918963))+_IQmpy(ib,_IQ(1.15470053837926));   //3/2变换

    id = _IQmpy(ialfa,Cosine) +_IQmpy(ibeta,Sine);
    iq = _IQmpy(ibeta,Cosine)- _IQmpy(ialfa,Sine) ;            //2/2变换
//======================================================================================================
//IQ电流PID调节控制
//======================================================================================================
    IQ_Ref=_IQdiv(_IQ(IQref),_IQ(E_Ding_DianLiu));//IQref为摇杆反馈的值，比上额定电流值变成标幺值，IQ_Ref为标幺值

    IQ_Ref_fil=_IQmpy(_IQ(0.2),IQ_Ref_fil)+_IQmpy(_IQ(0.8),IQ_Ref);         //目标值
    IQ_Fdb_fil=_IQmpy(_IQ(0.2),IQ_Fdb_fil)+_IQmpy(_IQ(0.8),iq);             //实际反馈值
    IQ_read=_IQmpy(IQ_Fdb_fil,_IQ(E_Ding_DianLiu));
    IQ_read=_IQmpy(IQ_read,_IQ(0.70721356));


    IQ_Error=IQ_Ref_fil - IQ_Fdb_fil;                                       //本次误差
    IQ_Error_read=_IQmpy(IQ_Error,_IQ(E_Ding_DianLiu));
    IQ_Error_error=IQ_Error - IQ_Error_before;                              //误差积分

    IQ_Up=_IQmpy(IQ_Kp,IQ_Error_error);
    IQ_Ui=_IQmpy(IQ_Ki,IQ_Error);
    IQ_Out_deta=IQ_Up  + IQ_Ui;

    IQ_Out=IQ_Out_before + IQ_Out_deta;

    IQ_OutMax=_IQ(2.8);        //电流限幅  原值3.0 限幅值0.3
    IQ_OutMin=_IQ(-2.8);

    if(IQ_Out>IQ_OutMax)     //正相限幅
    {
        IQ_Out=IQ_OutMax;
    }

    else if(IQ_Out<IQ_OutMin)      //反相限幅
    {
        IQ_Out=IQ_OutMin;
    }

    else
    {
        IQ_Out=IQ_Out;
    }


    IQ_Out_before=IQ_Out;
    IQ_Error_before=IQ_Error;
    IQ_Fdb_fil_before=IQ_Fdb_fil;
    Uq=IQ_Out;

//======================================================================================================
//ID电流PID调节控制
//======================================================================================================
    ID_Ref=_IQ(0.00);

    ID_Ref_fil=_IQmpy(_IQ(0.2),ID_Ref_fil)+_IQmpy(_IQ(0.8),ID_Ref);
    ID_Fdb_fil=_IQmpy(_IQ(0.2),ID_Fdb_fil)+_IQmpy(_IQ(0.8),id);
    ID_Fdb=id;
    ID_read=_IQmpy(ID_Fdb_fil,_IQ(E_Ding_DianLiu));
    ID_read=_IQmpy(ID_read,_IQ(0.70721356));
    ID_Error=ID_Ref_fil - ID_Fdb_fil ;
    ID_Error_read=_IQmpy(ID_Error,_IQ(4.2));
    ID_Error_error=ID_Error - ID_Error_before;    //误差积分

    ID_Up=_IQmpy(ID_Kp,ID_Error_error);
    ID_Ui=_IQmpy(ID_Ki,ID_Error);
    ID_Out_deta=ID_Up  + ID_Ui;
    ID_Out=ID_Out_before + ID_Out_deta;

    ID_OutMax=_IQ(2.5);
    ID_OutMin=_IQ(-2.5);

    if(ID_Out>ID_OutMax)        //正相限幅
    {
        ID_Out=ID_OutMax;
    }

    else if(ID_Out<ID_OutMin)    //反相限幅
    {
        ID_Out=ID_OutMin;
    }

    else
    {
        ID_Out=ID_Out;
    }


    ID_Out_before=ID_Out;
    ID_Error_before=ID_Error;
    ID_Fdb_old=ID_Fdb_fil;

    Ud=ID_Out;
/***PI滤波数据观测****/
    if(PI_Times<=200)
    {
        IQ_REF_WATCH[PI_Times]=IQ_Ref_fil;           //观测反馈的实际电流值数组
        IQ_OUT_WATCH[PI_Times]=IQ_Fdb_fil;             //观测目标电流值数组
        PI_Times++;
    }
    else PI_Times=0;
/***************************/
}

void SVPWM(void)      //SVPWM函数
{
    _iq t_01,t_02;
    //======================================================================================================
    //IPark变换aa
    //======================================================================================================
            Ualfa = _IQmpy(Ud,Cosine) - _IQmpy(Uq,Sine);
            Ubeta = _IQmpy(Uq,Cosine) + _IQmpy(Ud,Sine);

    //======================================================================================================
    //SVPWM实现
    //======================================================================================================
            B0=Ubeta;
            B1=_IQmpy(_IQ(0.8660254),Ualfa)- _IQmpy(_IQ(0.5),Ubeta);  // 0.8660254 = sqrt(3)/2
            B2=_IQmpy(_IQ(-0.8660254),Ualfa)- _IQmpy(_IQ(0.5),Ubeta); // 0.8660254 = sqrt(3)/2

            Sector=0;                //扇区判断
            if(B0>_IQ(0))
            {
                Sector =1;
            }

            if(B1>_IQ(0))
            {
                Sector =Sector +2;
            }

            if(B2>_IQ(0))
            {
                Sector =Sector +4;
            }


            X=Ubeta;//va
            Y=_IQmpy(_IQ(0.8660254),Ualfa)+ _IQmpy(_IQ(0.5),Ubeta);  // 0.8660254 = sqrt(3)/2 vb
            Z=_IQmpy(_IQ(-0.8660254),Ualfa)+ _IQmpy(_IQ(0.5),Ubeta); // 0.8660254 = sqrt(3)/2 vc


            if(Sector==1)
            {
                t_01=Z;
                t_02=Y;

                if((t_01+t_02)>_IQ(1))
                {
                    t1=_IQmpy(_IQdiv(t_01, (t_01+t_02)),_IQ(1));
                    t2=_IQmpy(_IQdiv(t_02, (t_01+t_02)),_IQ(1));
                }
                else
                {
                    t1=t_01;
                    t2=t_02;
                }
                Tb=_IQmpy(_IQ(0.5),(_IQ(1)-t1-t2));
                Ta=Tb+t1;
                Tc=Ta+t2;
            }
            else if(Sector==2)
            {
                t_01=Y;
                t_02=-X;

                 if((t_01+t_02)>_IQ(1))
                {
                    t1=_IQmpy(_IQdiv(t_01, (t_01+t_02)),_IQ(1));
                    t2=_IQmpy(_IQdiv(t_02, (t_01+t_02)),_IQ(1));
                }
                else
                {
                    t1=t_01;
                    t2=t_02;
                }
                Ta=_IQmpy(_IQ(0.5),(_IQ(1)-t1-t2));
                Tc=Ta+t1;
                Tb=Tc+t2;
            }
            else if(Sector==3)
            {
                t_01=-Z;
                t_02=X;

                 if((t_01+t_02)>_IQ(1))
                {
                    t1=_IQmpy(_IQdiv(t_01, (t_01+t_02)),_IQ(1));
                    t2=_IQmpy(_IQdiv(t_02, (t_01+t_02)),_IQ(1));
                }
                else
                {
                    t1=t_01;
                    t2=t_02;
                }
                Ta=_IQmpy(_IQ(0.5),(_IQ(1)-t1-t2));
                Tb=Ta+t1;
                Tc=Tb+t2;
            }
            else if(Sector==4)
            {
                t_01=-X;
                t_02=Z;
                 if((t_01+t_02)>_IQ(1))
                {
                    t1=_IQmpy(_IQdiv(t_01, (t_01+t_02)),_IQ(1));
                    t2=_IQmpy(_IQdiv(t_02, (t_01+t_02)),_IQ(1));
                }
                else
                {
                    t1=t_01;
                    t2=t_02;
                }
                Tc=_IQmpy(_IQ(0.5),(_IQ(1)-t1-t2));
                Tb=Tc+t1;
                Ta=Tb+t2;
            }
            else if(Sector==5)
            {
                t_01=X;
                t_02=-Y;
                 if((t_01+t_02)>_IQ(1))
                {
                    t1=_IQmpy(_IQdiv(t_01, (t_01+t_02)),_IQ(1));
                    t2=_IQmpy(_IQdiv(t_02, (t_01+t_02)),_IQ(1));
                }
                else
                {
                    t1=t_01;
                    t2=t_02;
                }
                Tb=_IQmpy(_IQ(0.5),(_IQ(1)-t1-t2));
                Tc=Tb+t1;
                Ta=Tc+t2;
            }
            else if(Sector==6)
            {
                t_01=-Y;
                t_02=-Z;
                 if((t_01+t_02)>_IQ(1))
                {
                    t1=_IQmpy(_IQdiv(t_01, (t_01+t_02)),_IQ(1));
                    t2=_IQmpy(_IQdiv(t_02, (t_01+t_02)),_IQ(1));
                }
                else
                {
                    t1=t_01;
                    t2=t_02;
                }
                Tc=_IQmpy(_IQ(0.5),(_IQ(1)-t1-t2));
                Ta=Tc+t1;
                Tb=Ta+t2;
            }

            MfuncD1=_IQmpy(_IQ(2),(_IQ(0.5)-Ta));//倒三角计算
            MfuncD2=_IQmpy(_IQ(2),(_IQ(0.5)-Tb));
            MfuncD3=_IQmpy(_IQ(2),(_IQ(0.5)-Tc));
    //======================================================================================================
    //EVA全比较器参数赋值，用于驱动电机
    //======================================================================================================
            MPeriod = (int16)(T1Period * Modulation);/*MPeriod = 3750 * 1 =3750 */
/*PWM1 占空比的赋值*/
            Tmp = (int32)MPeriod * MfuncD1;/*Tmp -3750~3750 */
            Tmp = (Tmp>>16) + (T1Period>>1);/*Tmp  -1875~1875 + 3750/2 = 0~3750*/
            /* PWM周期MPeriod 乘以 其占空比MfuncD1，得到比较寄存器的值，
             * 但因为此时的占空比经过范围变换处理，所以还不是真正的比较寄存器的值
             * Tmp 除以2，实现占空比由（-1,1）到（-0.5,0,5）的还原，
             * 然后右移15位，也就是取整，将该数从Q15格式转换成Q0格式，综合起来就是(Tmp>>16)
             * 然后加上0.5（对应MPeriod>>1）的偏移，把占空比还原到（0，1），此时的结果就是比较寄存器的值*/

            /*
            if(Tmp >MPeriod - 500)
                Tmp = MPeriod - 500;
            if(Tmp < 100) Tmp = 100;
            */

            EPwm1Regs.CMPA.half.CMPA = (int16)(Tmp) ;//>>16) + (int16)(T1Period>>1); // Q0 = (Q15->Q0)/2 + (Q0/2)
/*PWM2 占空比的赋值*/
            Tmp = (int32)MPeriod * MfuncD2;                    // Q15 = Q0*Q15，计算全比较器CMPR2赋值      MduncD2去掉(int32)
            Tmp = (Tmp>>16) + (T1Period>>1);
            /*
            if(Tmp >MPeriod - 500)
                Tmp = MPeriod - 500;
            if(Tmp < 100) Tmp = 100;
            */
            EPwm2Regs.CMPA.half.CMPA = (int16)(Tmp);//>>16) + (int16)(T1Period>>1); // Q0 = (Q15->Q0)/2 + (Q0/2)
/*PWM3 占空比的赋值*/
            Tmp = (int32)MPeriod * MfuncD3;                    // Q15 = Q0*Q15，计算全比较器CMPR3赋值     MduncD3去掉(int32)
            Tmp = (Tmp>>16) + (T1Period>>1);
            /*
            if(Tmp >MPeriod - 500)
                Tmp = MPeriod - 500;
            if(Tmp < 100) Tmp = 100;
            */
            EPwm3Regs.CMPA.half.CMPA = (int16)(Tmp);//>>16) + (int16)(T1Period>>1); // Q0 = (Q15->Q0)/2 + (Q0/2)

}