bc_user3.c.bak

感应电动机的实例仿真例子

#include <math.h>
__declspec(dllexport)

#define Pi  3.14159265359
#define Iqemax  30
#define Iqemin  -30
#define Vqemax  200
#define Vqemin  -200
#define Vdemax  75
#define Vdemin  -75

void bc_user3 (t, delt, in, out)
double t, delt;
double *in, *out;
{

static double Ts = 1./10000., Tsv= 1./1000.;
static double w=2*Pi*60., f = 60.;


//system
static double L=0.0033, R=0.1, C=0.0025;


//---------------------------------//
//------------Voltage--------------//
//---------------------------------//

static double Vdc = 310.,dVdc=0.,Vdco=0.,Vdcn=0.,Vdc_old;
static double Vdcref=310.,Vdcref_set=310.,Vdc_f=0.,Vdc_ff=0.;
static double Eas=0.,Ebs=0.,Ecs=0.,Eab=0.,Ebc=0.,Eca=0.,Eds=0.,Eqs=0.,Eqe=0.,Ede=0.,Ede_f=0.,Eqe_f=0.;
static double Eqeref=180.;
static double Vqeanti=0., Vdeanti=0.;
static double Vqerefinteg=0.,Vderefinteg=0.,Vqerefa=0.,Vderefa=0.,Vqerefb=0.,Vderefb=0.;
static double Vasi_ref=0., Vbsi_ref=0., Vcsi_ref=0.;
static double Vdcerr=0., Vqerefc=0.,Vderefc=0.,Vqeref=0.,Vderef=0.;
static double Vqsref=0.,Vdsref=0.;


//---------------------------------//
//------------Current--------------//
//---------------------------------//


static double Ia=0.,Ib=0.,Ic=0.,Idc=0.;
static double Iqs=0.,Ids=0.,Iqeref=0.,Iqerefinteg=0.,Iqerefa=0.,Iqerefb=0.,Iqeanti=0.,Ideref=0.;
static double Iqe=0.,Ide=0.,Iqeerr=0., Ideerr=0.;


//---------------------------------//
//----------------etc--------------//
//---------------------------------//

static double m=0.,a=0.,P=0.,G=0.,U=0.,Ki=0.,Kiv=0.,Kpv = 0.,Kv=0.;
static double Kpiq = 0.,  Kiiq=0.,Kpid=0.,Kiid=0. ;
static double P_con=0.,count=0., gita=1.,theta = 0., ratio=0.,Pout=0.;
static double angle_count=0.,run_flag=0.;

//---------------------------------//
//------cutoff-frequency-----------//
//---------------------------------//

static double Wc_vol=80.,Wc_curr=3000.;

//---------------------------------//
//------angle detection------------//
//---------------------------------//

static double angle=0., kp_ang=0.005,KiT_ang=0.0000714,Err_ang=0.;

//---------------------------------//
//--second low-pass filter(angle)--//
//---------------------------------//

static double Fang_cut=10.,La_vtg=0.,Lb_vtg=0.;
//---------------------------------//
//--second low-pass filter(Vdc)----//
//---------------------------------//

static double F_cut=200.,La_Vdc=0.,Lb_Vdc=0.;

//---------------------------------//
//-------Space Vector PWM----------//
//---------------------------------//

static double Ta=0.,Tb=0.,Tc=0.;
static double Tmax=0.,Tmin=0.,Teff=0.,Tzero=0.,Toffs=0.;
static double Tga=0.,Tgb=0.,Tgc=0.,Sa=0.,Sb=0.,Sc=0.;
static double Tmode=0.,mode=0.,seq=1.;



//---------------------------------//
//--------system input-------------//
//---------------------------------//


   Ia  = in[0];
   Ib  = in[1];
   Eab = in[2];
   Ebc = in[3];
   //0.  = in[4];
   //0.  = in[5];
  // C   = in[4];
   Vdc = in[4];
   Pout= in[5];
   //Vdc_ff = in[7];
   //0.  = in[10];
   //0.  = in[11];
   //0.  = in[12];
   //0.  = in[13];
   //0.  = in[15];
   //0.  = in[16];
   //0.  = in[17];
   //0.  = in[18];
   //0.  = in[19];


//---------------------------------------------------------------------------//
















//---------------------------------------------------------------------------//
//-------phase voltage calculation from line to line voltage-----------------//
//---------------------------------------------------------------------------//

           Eca=-(Eab+Ebc);
	   Eas=(Eab-Eca)/3.;
	   Ebs=(Ebc-Eab)/3.;
	   Ecs=-(Eas+Ebs);

	   Eqs=Eas;
           Eds=(Ecs-Ebs)/sqrt(3);




//----------------------------------------------------------------------------//
//---------------------angle detection----------------------------------------//
//----------------------------------------------------------------------------//


       a=-Ede_f;
       angle=angle+kp_ang*(a-Err_ang)+KiT_ang*a;
       Err_ang=a;
       a=angle+2.*Pi*60.*Ts;
       angle=a+((a>Pi) ? -2.*Pi : (a<-Pi) ? 2.*Pi  : 0.);









//--------------------------------------------------------------------------------//
//---------------------------------low-pass  filter-------------------------------//
//--------------------------------------------------------------------------------//   
  
			   a=2.*Pi*Fang_cut;
	       	       La_vtg=(2.-a*Ts)/(2.+a*Ts);
			   Lb_vtg=(a*Ts)/(2.+a*Ts);
       
			   a = Eqs*cos(angle) - Eds*sin(angle);
			   Eqe_f=La_vtg*(Eqe_f)+Lb_vtg*(a+Eqe);
			   Eqe=a;

			   a = Eqs*sin(angle) + Eds*cos(angle);
			   Ede_f=La_vtg*(Ede_f)+Lb_vtg*(a+Ede);
			   Ede=a;





	












//--------------------------------------------------------------------------------//
//--------------------low-pass  filter--------------------------------------------//
//--------------------------------------------------------------------------------//        
       
			   a=2.*Pi*F_cut;
			   La_Vdc=(2.-a*Ts)/(2.+a*Ts);
			   Lb_Vdc=(a*Ts)/(2.+a*Ts);
			   Vdc_f=La_Vdc*(Vdc_f)+Lb_Vdc*(Vdc+Vdco);
			   Vdco=Vdc;

		
	


	  





		






		//----------------------------------------------------------------//
		//---------------------Voltage Controller-------------------------//
		//----------------------------------------------------------------//



		      
		       Vdcn=(Vdc_f+0.00001);

		     

		       count = count+1.;


		       if (count == 6.){


		        if(Vdcref_set<340)
		        Vdcref_set=Vdcref_set +1.;
		        else
		        Vdcref_set=340.;
		        
                     

					    Kpv=2*gita*Wc_vol*(C*Vdcref_set)/(1.5*Eqeref);
		             Kiv=Wc_vol*Wc_vol*5.*(C*Vdcref_set)/(1.5*Eqeref);

		            Vdcerr  =  Vdcref_set - Vdcn;
		 		       //Vdcerr  =  Vdcref - Vdcn;
		             Iqeanti=Iqerefb-Iqeref;
		             Iqerefinteg = Iqerefinteg+Kiv*Ts*6.*(Vdcerr-(1./Kpv)*Iqeanti);
		             Iqerefa=Iqerefinteg-Kpv*Vdcn;
		             Iqerefb=Iqerefa+Pout/(1.5*Eqeref);
		             Iqeref = ((Iqerefb>Iqemax) ? Iqemax : (Iqerefb<Iqemin) ? Iqemin : Iqerefb);

		             Ideref=0.;
		             count = 0.;

					 }


			//---------------------------------------------------------------------------//


		//----------------------------------------------------------------//
		//------------------3 phase --> 2 phase---------------------------//
		//----------------------------------------------------------------//   

		            Ic = -Ia-Ib;
		            Iqs = Ia;
		            Ids = (-Ib+Ic)/sqrt(3);

		//----------------------------------------------------------------//
		//----- Stationary-to-Rotating co-ordinate transformation---------//
		//----------------------------------------------------------------//         
			
				Iqe = Iqs*cos(angle) - Ids*sin(angle);  
		        	Ide = Iqs*sin(angle) + Ids*cos(angle);









         
      
		//----------------------------------------------------------------//
		//---------------------Current Controller-------------------------//
		//----------------------------------------------------------------// 
		           Kpiq=L*Wc_curr;
		           Kpid=L*Wc_curr;
		           Kiiq=R*Wc_curr;
		           Kiid=R*Wc_curr;
        
              
		     //q-axis
		           Vqeanti=Vqerefc-Vqeref;
		   	       Iqeerr = -Iqeref + Iqe;
		       	   Vqerefinteg = Vqerefinteg+Kiiq*Ts*(Iqeerr-(1./Kpiq)*Vqeanti);
		           Vqerefa=Vqerefinteg+Kpiq*Iqeerr;
		           Vqerefb=Eqe_f;
		           Vqerefc=Vqerefa+Vqerefb-(w*L*Ide);
			       Vqeref = ((Vqerefc>Vqemax) ? Vqemax : (Vqerefc<Vqemin) ? Vqemin : Vqerefc);

		    //d-axis
		           Vdeanti=Vderefc-Vderef;
		   	       Ideerr = -Ideref + Ide;
			       Vderefinteg = Vderefinteg+Kiid*Ts*(Ideerr-(1./Kpid)*Vdeanti);
		           Vderefa=Vderefinteg+Kpid*Ideerr;
		           Vderefb=Ede_f;
		           Vderefc=Vderefa+Vderefb+(w*L*Iqe);
			       Vderef = ((Vderefc>Vdemax) ? Vdemax : (Vderefc<Vdemin) ? Vdemin : Vderefc);







		//----------------------------------------------------------------//
		//---------------------input power--------------------------------//
		//----------------------------------------------------------------//
		
		    	P_con=1.5*(Ede_f*Ide+Eqe_f*Iqe);



		
		//----------------------------------------------------------------//
		//--------------------Idc calculation-----------------------------//
		//----------------------------------------------------------------//

		        Idc=(Ta*Ia+Tb*Ib+Tc*Ic)/Ts;

		

  



//-------------------------------------------------------------------------------------------------//






		//----------------------------------------------------------------//
		//----- Rotating-to-stationary co-ordinate transformation---------//
		//----------------------------------------------------------------//

		          Vqsref =  Vqeref * cos(angle) + Vderef * sin(angle);
			      Vdsref =  -Vqeref * sin(angle) + Vderef * cos(angle);






		//----------------------------------------------------------------//
		//------------ 2 phase ---> 3 phase-------------------------------//
		//----------------------------------------------------------------//         

		          Vasi_ref =  Vqsref;
		          Vbsi_ref = -sqrt(3.)/2. * Vdsref - (1./2.) * Vqsref;
			  Vcsi_ref = sqrt(3.)/2. * Vdsref - (1./2.) * Vqsref;
      




	



		//----------------------------------------------------------------//
		//------------ imaginary phase time calculation-------------------//
		//----------------------------------------------------------------//

		              Ta = Vasi_ref*Ts/(Vdc_f+0.000000000001);
			      Tb = Vbsi_ref*Ts/(Vdc_f+0.000000000001);
			      Tc = Vcsi_ref*Ts/(Vdc_f+0.000000000001);

		//----------------------------------------------------------------//
		//---------------3-element Sort Algorithm-------------------------//
		//----------------------------------------------------------------//

		          Tmax = Ta;
		          Tmin = Ta;
		          if(Tb>Tmax)	Tmax = Tb;
		          if(Tb<Tmin)	Tmin = Tb;
		          if(Tc>Tmax)	Tmax = Tc;
		          if(Tc<Tmin)	Tmin = Tc;

		//----------------------------------------------------------------//
		//-----------------Effective Time Calculation---------------------//
		//----------------------------------------------------------------//

		              Teff = Tmax-Tmin;
			      Tzero = Ts-Teff;
			      Toffs = Tzero/2. - Tmin;

		//----------------------------------------------------------------//
		//---------------------OverModulation-----------------------------//
		//----------------------------------------------------------------//

		          if(Tzero < 0.){
		          	Ta *= Ts/Teff;
		          	Tb *= Ts/Teff;
		         	Tc *= Ts/Teff;
		          	Toffs = -Tmin*Ts/Teff;
		             }

		         Tga = Ta + Toffs;
		    	 Tgb = Tb + Toffs;
		    	 Tgc = Tc + Toffs;

        //----------------------------------------------------------------//
		//---------------------sequency check-----------------------------//
		//----------------------------------------------------------------//


		         seq=-seq;


		         if(seq>0.){
		            Tga = Ts - Tga;
			        Tgb = Ts - Tgb;
		         	Tgc = Ts - Tgc;
		            } 


       
	

//---------------------------------------------------------------------------------//
//------------------------system output--------------------------------------------//
//---------------------------------------------------------------------------------//   
   
         out[0]  = Tga ;
         out[1]  = Tgb ;
         out[2]  = Tgc ;
    	   out[3] = seq;
	      out[4]  = Iqeref;
         out[5]  = Iqe;
         out[6]  = Ideref;
         out[7]  = Ide;
         out[8]  = Vdcref_set;
         out[9]  = Vdc;
         out[10]  = Idc;
         out[11]  = angle;
        // out[11]  = dVdcbpf;
        // out[10]  = Vdcbpf;
        // out[10]  = dVdcbpf;
        // out[11] = C_cal;
        // out[11] = C_new;
        // out[11]  = Vqeref;
        // out[11]  = Ia;
         //out[12] = Vderef;
	    	// out[11] = Vdc_f;
		   //out[12] = Vdc_ff;
         //out[11] = C_cal;
         //out[14] = Vdc_ff;
         //out[15] =Iqeo;
         //out[16] =Vdcbpf;
         //out[17] =Idcbpf;
         //out[18] =Vdcbpf_rms;
         //out[19] =Idcbpf_rms;o


//main end
}