API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 22nd, 2020
88
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 14.69 KB | None | 0 0
raw download clone embed print report
  1. #define IN_MAIN
  2. #include "sim.h"
  3.  
  4. /*-------------------------------------------------------------------------*/
  5.  
  6. #include <math.h>
  7. #include <stdio.h>
  8. //#include <io.h>
  9. #include "zbiory\ela.h"
  10. #include "zbiory/limit.C"
  11. #include "zbiory/kat.c"
  12.  
  13. #define p2 1.414213562  /* pierwiastek z 2 */
  14. #define p3 1.732050808  /* pierwiastek z 3 */
  15. #define p6 2.449489743  /* pierwiastek z 6 */
  16.  
  17. #define M_PI    3.1415926535897932384626433832795
  18.  
  19. #define   TWZG   0.1*M_PI  // przelicznik z czasu rzeczywistego na wzgledny
  20.                           // TWZG=2*PI*fsieci [ms]
  21.  
  22.  
  23. int M=7;       /* liczba calkowanych zmiennych - model silnika */
  24. int Np=2,Nk=5; /* nr. pierwszego i ostatniego r.r. ukladu regulacji */
  25.  
  26. /*------------------------------------------------------------------------*/
  27. /* Parametry silnika o mocy 1.5 kW typ 2Sg90L4                            */
  28. /*------------------------------------------------------------------------*/
  29. double Rs=0.0584,Rr=0.0559,Lm=2.171,Ls=2.246,Lr=2.246,JJ=38.4*3.0;
  30.  
  31. double omegaR;  /* predkosc katowa wirnika */
  32. double isx,isy; /* skladowe pradu stojana */
  33. double frx,fry; /* skladowe strumienia skojarzonego wirnika */
  34. double usx,usy; /* skladowe napiecia stojana */
  35. double me,m0;   /* moment elektromagnetyczny i obciazenia */
  36. double fr;      /* modul strumienia skojarzonego wirnika */
  37. double is;      /* modul pradu stojana */
  38. double us;      /* modul napiecia stojana */
  39. double omegaU;  /* zadana pulsacja napiecia stojana */
  40. double US;      /* zadany modul napiecia stojana */
  41. double USX,USY; /* zadane skladowe napiecia stojana */
  42. double ud;  /* napiecie w obwodzie posredniczacym pradu stalego */
  43.  
  44.  
  45.  
  46. //wartosci zadane
  47. double omegaRzad=1.0;   // zadana czestotliwosc napiecia stojana
  48. double frzad=1.0;    // zadany strumien skojarzony wirnika
  49. //nastawy regulatorów
  50. double kpomegaR, kiomegaR, kpfr, kifr, kpd, kid, kpq, kiq;
  51. //zmienne w układzie sterowania
  52. double ro;
  53. double usd, usq;
  54.  
  55.  
  56. /*------------------------------------------------------------------------*/
  57. /* Deklaracje zmiennych globalnych                                        */
  58. /*------------------------------------------------------------------------*/
  59. double w,a1,a2,a3,a4,a5,a6,a7; /* wspolczynniki w modelu silnika */
  60. //double tau;     /* czas wzgledny */
  61. //double h,ht;    /* krok calkowania rzeczywisty i wzgledny */
  62. //double trapH;   /* krok obliczen dla ukladu regulacji */
  63. //double Timp;    /* okres impulsowania */
  64. //double impuls=0.0; /* czas do odmierzania zalaczenia ukladu regulacji */
  65. double t0,t1,t2;/* czasy zalaczen wektorow */
  66. double roU=0.0; /* kat polozenia wektra napiecia stojana */
  67. //float tab[7];   /* tablica rysowanych na ekranie danych */
  68. int SYNCH;      /* zmienna do synchronizacji z PWM */
  69. int wek;        /* numer wektora wyjsciowego falownika 0-1-2-3-4-5-6-7 */
  70. int sek;        /* numer sektora polozenia wektora napiecia 1-2-3-4-5-6 */
  71. //double DD[8][4];
  72.  
  73.  
  74. /*---------------------------------------------*/
  75. /* Deklaracje zmiennych                        */
  76. /*---------------------------------------------*/
  77.  
  78. double t,tau;   /* czas,czas wzgledny */
  79. double h,ht=1; /* czas wzgledny, krok calkowania */
  80. double Timp,impuls;
  81. double YY[32];
  82. double DD[8][4];
  83. float tab[7];
  84.  
  85.  
  86. double TIME_s, TIME;
  87. double zmienna1, zmienna2, zmienna3, zmienna4; //przykładowe zmienne
  88. double E_omega, P_omega, I_omega, E_isq, P_isq, I_isq, Usq_zad, E_fr, I_fr, P_fr;
  89.  
  90.  
  91.  
  92.  
  93. /*------------------------------------------*/
  94. /* deklaracje funkcji dolaczonych w PROJECT */
  95. /*------------------------------------------*/
  96. double limit(double wejscie, double ograniczenie);
  97. double nzero(double x,double ogr);
  98. void PWMU_3WR(/* Wielkosci WEJsciowe: */
  99.          double US,     // zadany modul napiecia wyjsciowego
  100.          double roU,    // zadany kat polozenia wektora napiecia wyjsciowego
  101.          double ud,     // napiecie stale w obwodzie posredniczacym
  102.          double Timp,   // okres impulsowania
  103.          double h,      // krok calkowania
  104.          /* Wielkosci WYJsciowe - zwracane: */
  105.          double *usx,   // skladowa X chwilowego napiecia wyjsciowego
  106.          double *usy,   // skladowa Y chwilowego napiecia wyjsciowego
  107.          double *t0,    // czas t0 wektora zerowego
  108.          double *t1,    // czas t1 wektora aktywnego
  109.          double *t2,    // czas t2 wektora aktywnego
  110.          int *SYNCH,    // znacznik poczatku okresu impulsowania - do synchronizacji PWM z ukladem regulacji
  111.          int *wektor,   // numer wektora wyjsciowego falownika 0-1-2-3-4-5-6-7
  112.          int *sektor    // numer sektora polozenia wektora napiecia 1-2-3-4-5-6
  113.          );
  114.  
  115. /*-------------------------------------------------------------------------*/
  116. /*                   Uklad rownan rozniczkowych                            */
  117. /*-------------------------------------------------------------------------*/
  118. void F4DERY(double DV[32], double V[32])
  119. {
  120.  
  121. tau=V[01];        /* zmienne calkowane */
  122. isx=V[1];  isy=V[2];
  123. frx=V[3];  fry=V[4];
  124. omegaR=V[5];
  125.  
  126. DV[0]=1; /* Czas */
  127. /* rownania modelu silnika */
  128. DV[1]=a1*isx+a2*frx+omegaR*a3*fry+a4*usx;
  129. DV[2]=a1*isy+a2*fry-omegaR*a3*frx+a4*usy;
  130. DV[3]=a5*frx+a6*isx-omegaR*fry;
  131. DV[4]=a5*fry+a6*isy+omegaR*frx;
  132. DV[5]=((frx*isy-fry*isx)*Lm/Lr-m0)/JJ;
  133.  
  134.  
  135.  
  136. }
  137.  
  138. /*------------------------------------------------------------------*/
  139. /* rownania rozniczkowe ukladu regulacji                */
  140. /*------------------------------------------------------------------*/
  141. void TRAPDERY(double DV[32], double V[32])
  142. {
  143. //WPROWADZIC ZALEZNOSCI
  144. // regulator predkosci katowej wirnika
  145. // regulator strumienia wirnika
  146. // regulator pradu isd
  147. // regulator pradu isq
  148.  
  149.  
  150. }
  151.  
  152.  
  153. /*-------------------------------------------------------------------------*/
  154. #include "zbiory\PAR.C"
  155. #include "zbiory\F4.C"
  156. #include "zbiory/TRAPEZ.C"
  157.  
  158.  
  159.  
  160.  
  161. void onStartup()
  162. {
  163. /*-------------------------------------------------------------------------*/
  164. /*                    Wczytanie wartosci poczatkowych                      */
  165. /*-------------------------------------------------------------------------*/
  166.  
  167.  
  168. ht=0.005;        /* krok calkowania w milisekundach */
  169. h=ht*TWZG;       /* krok calkowania przeliczony na czas wzgledny */
  170.  
  171.  
  172. Timp=.2*TWZG;    // okres impulsowania falownika
  173. m0=0.1;      // moment obciazenia
  174. ud=1.72;          // napiecie w obwodzie posredniczacym pradu stalego
  175. //omegaRzad=1.0;   // zadana czestotliwosc napiecia stojana
  176.  
  177. omegaRzad=1.0;   // zadana czestotliwosc napiecia stojana
  178. frzad=1.0;   // zadany strumien skojarzony wirnika
  179. //dla sterowania skalarnego
  180.     omegaU=1.0;      // zadana pulsacja napiecia stojana
  181.     US=1.0;          // zadany modul napiecia stojana
  182. /*---------------------*/
  183. /* nastawy regulatorow */
  184. /*---------------------*/
  185. // predkosci
  186. kpomegaR=50;
  187. kiomegaR=.1;
  188. // strumienia wirnika
  189. kpfr=50;
  190. kifr=.005;
  191. // pradu w osi d
  192. kpd=5;
  193. kid=.5;
  194. // pradu w osi q
  195. kpq=1;
  196. kiq=50;
  197.  
  198. /*-------------------------------------------------*/
  199. /* Obliczanie wspolczynnikow rownan modelu silnika */
  200. /*-------------------------------------------------*/
  201. w=Ls*Lr-Lm*Lm;
  202. a1=-(Rs*Lr*Lr+Rr*Lm*Lm)/(Lr*w);
  203. a2=Rr*Lm/(Lr*w); a3=Lm/w; a4=Lr/w;
  204. a5=-Rr/Lr; a6=Rr*Lm/Lr;
  205. a7=w/Lr;
  206.  
  207.  
  208.  
  209.  
  210. }
  211.  
  212. /*-------------------------------------------------------------------------*/
  213. /*--------------P R O G R A M   G L O W N Y--------------------------------*/
  214. /*-------------------------------------------------------------------------*/
  215. void simmain()
  216. {
  217. /*deklaracje zmiennych lokalnych */
  218. double Y[32]; /* zmienne calkowane modelu silnika */
  219. double X[32]; /* zmienne calkowane ukladu regulacji */
  220.  
  221.  
  222.  
  223. int i,J; /* liczniki petli */
  224. int LL=0;
  225.  
  226.  
  227.  
  228.  
  229.  
  230. /*-------------------------------------------------------------------------*/
  231. /*         Obliczanie warunkow poczatkowych do rownan rozniczkowych        */
  232. /*-------------------------------------------------------------------------*/
  233. for (J=0;J<M;J++) Y[J]=0;  // zerowe warunki poczatkowe
  234. for (J=0;J<M;J++) X[J]=0;  // dla zmiennych ukladu sterowania - zerowe
  235.  
  236.  
  237.  
  238.  
  239.  
  240. /*-------------------------------------------------------------------------*/
  241. /*                           Petla glowna                                  */
  242. /*-------------------------------------------------------------------------*/
  243. do
  244.     {
  245.     //for (J=0;J<(Nk+1);J++) YY[J]=Y[J];
  246.    
  247.     TIME+=ht;
  248.     zmienna1=1; zmienna2=12; zmienna3=-4; zmienna4=8;
  249.    
  250.  
  251.    
  252.     // Prędkosc katowa
  253.     E_omega = omegaRzad - omegaR;
  254.     P_omega = kpomegaR*E_omega;
  255.     I_omega += kiomegaR*ht*E_omega;
  256.    
  257.     if(I_omega > 1) I_omega = 1;
  258.     if(I_omega < -1) I_omega = -1;
  259.    
  260.    
  261.     isq_zad = P_omega + I_omega;
  262.     if(isq_zad > 1) isq_zad = 1;
  263.     if(isq_zad < 0) isq_zad = 0;
  264.    
  265.    
  266.     // transformacja isq
  267.     isq=-isx*sin(ro)+isy*cos(ro);
  268.    
  269.     E_isq = isq_zad - isq;
  270.     P_isq = kpq*E_isq;
  271.     I_isq += kiq*ht*E_isq;
  272.    
  273.     if(I_isq> 1) I_isq = 1;
  274.     if(I_isq < -1) I_isq = -1;
  275.  
  276.     Usq_zad = P_isq + I_isq;
  277.     if(Usq_zad > 1) Usq_zad = 1;
  278.     if(Usq_zad < 0) Usq_zad = 0;
  279.  
  280.     /* kat poloľenia wektora napi©cia stojana */
  281.     roU+=omegaU*h; // narastanie kata
  282.     if(roU>2*M_PI) roU-=2*M_PI; // ograniczenie zakresu kata roU
  283.     if(roU<0) roU+=2*M_PI;      // ograniczenie zakresu kata roU
  284.    
  285.    
  286.     // Psi
  287.     E_fr = frzad - fr;
  288.     P_fr = kpf * E_fr;
  289.     I_fr = kif * ht * E_fr;
  290.    
  291.     if(I_fr > 1) I_fr = 1;
  292.     if(I_fr < -1) I_fr = -1;
  293.    
  294.     isd_zad = P_fr + I_fr;
  295.     if(isd_zad > 1) isd_zad = 1;
  296.     if(isd_zad < 0) isd_zad = 0;
  297.    
  298.     // transformacja is alfa do isd
  299.     isd=isx*cos(ro)+isy*sin(ro);
  300.    
  301.     E_isd = isd_zad - isd;
  302.     P_isd = kpd*E_isd;
  303.     I_isd += kid*ht*E_isq;
  304.    
  305.     if(I_isd> 1) I_isd = 1;
  306.     if(I_isd < -1) I_isd = -1;
  307.  
  308.     Usd_zad = P_isd + I_isd;
  309.     if(Usd_zad > 1) Usd_zad = 1;
  310.     if(Usd_zad < 0) Usd_zad = 0;
  311.    
  312.     usx = cos(ro) * Usd_zad - sin(ro) * Usq_zad
  313.     usy = sin(ro) * Usd_zad + cos(ro) * Usq_zad
  314.    
  315.     US = sqrt(pow(Usx_zad, 2) + pow(Usy_zad, 2));
  316.    
  317.     if(SYNCH) // uklad sterowania
  318.         {
  319.         /* obliczenie zmiennych obserwowanych */
  320.         is=sqrt(isx*isx+isy*isy);   // modul strumienia stojana
  321.         fr=sqrt(frx*frx+fry*fry);   // modul strumienia skojarzonego wirnika
  322.         me=(frx*isy-fry*isx)*Lm/Lr; // moment elektromagnetyczny silnika
  323.  
  324.         /* obliczenie zmiennych do ukladu sterowanie */
  325.         //WPROWADZIC ZALEZNOSCI
  326.  
  327.  
  328.         /* wywolanie podprogramu - Regulatory PI */
  329.         TRAPEZ(Np,Nk,Timp,X);
  330.  
  331.  
  332.  
  333.         // transformacja napiec dq -> xy, ro jest położeniem osi d względem układu nieruchomego
  334.  
  335.         // obliczenie zadanego modulu napiecia stojana
  336.    
  337.         // wyznaczenie kata polozenia wektoran napiecia stojana
  338.    
  339.        
  340.        
  341.        
  342.         }
  343.  
  344.  
  345.  
  346.     /* PWM napieciowy */
  347.     PWMU_3WR(US,roU,ud,Timp,h,&usx,&usy,&t0,&t1,&t2,&SYNCH,&wek,&sek);
  348.     /*-------------------------------------------------------------------------*/
  349.     /*             Rozwiazanie ukladu rownan rozniczkowych                     */
  350.     /*-------------------------------------------------------------------------*/
  351.  
  352.     F4(M,h,Y); // SILNIK rownania rozniczkowe - rozwiazanie metoda RK4
  353.  
  354.  
  355.  
  356.    
  357.     /* skokowe zmieny wielkosci zadanych i zaklocajacych */
  358.     if(TIME>450) m0=1;
  359.     if(TIME>700) frzad=0.6;
  360.     if(TIME>850) frzad=1;
  361.     if(TIME>900) m0=0.1;
  362.     if(TIME>1200) omegaRzad=-1.0;
  363.     if(TIME>1500) m0=1.2;
  364.     if(TIME>1700) m0=-1.5;
  365.     if(TIME>1850) m0=0.2;
  366.  
  367.  
  368.  
  369.  
  370.  
  371.  
  372.  
  373.    
  374.     //if(TIME>50) {zmienna1=11; zmienna2=2; zmienna3=-14; zmienna4=18;  }
  375.     //if(TIME>60) {zmienna1=-1; zmienna2=-2; zmienna3=4; zmienna4=8;    }
  376.    
  377.    
  378.  
  379.  
  380.  
  381.  
  382.  
  383.    
  384.  
  385.     /*-------------------------------------------------------------------------*/
  386.     /*                              Grafika                                    */
  387.     /*-------------------------------------------------------------------------*/
  388.     } while(WinSimTick());
  389. }
  390.  
  391.  
  392.  
  393.  
  394.  
  395.  
  396. /*------------------------------------------------------------*/
  397. /* obliczenie czasow zalaczen kluczy falownika                */
  398. /* Modulacja szerokosci impulsow przez obrot wektora napiecia */
  399. /* 4 wektory aktywne, zmiana kolejnosci wektorow aktywnych    */
  400. /* zadawane sa: MODUL i KAT POLOZENIA wektora napiecia        */
  401. /*------------------------------------------------------------*/
  402.  
  403. #include <math.h>
  404.  
  405.  
  406. void PWMU_3WR(/* Wielkosci WEJsciowe: */
  407.          double US,     // zadany modul napiecia wyjsciowego
  408.          double roU,    // zadany kat polozenia wektora napiecia wyjsciowego
  409.          double ud,     // napiecie stale w obwodzie posredniczacym
  410.          double Timp,   // okres impulsowania
  411.          double h,      // krok calkowania
  412.          /* Wielkosci WYJsciowe - zwracane: */
  413.          double *usx,   // skladowa X chwilowego napiecia wyjsciowego
  414.          double *usy,   // skladowa Y chwilowego napiecia wyjsciowego
  415.          double *t0,    // czas t0 wektora zerowego
  416.          double *t1,    // czas t1 wektora aktywnego
  417.          double *t2,    // czas t2 wektora aktywnego
  418.          int *SYNCH,    // znacznik poczatku okresu impulsowania - do synchronizacji PWM z ukladem regulacji
  419.          int *wektor,   // numer wektora wyjsciowego falownika 0-1-2-3-4-5-6-7
  420.          int *sektor    // numer sektora polozenia wektora napiecia 1-2-3-4-5-6
  421.          )
  422.  
  423. {
  424. static double impuls=0.0;
  425. static int NroU;
  426. static int idu1,idu2,idu0a,idu0b;
  427. static int cykl=-1;
  428. static double USX,USY;
  429. static double wt;
  430. static int temp=0;
  431. static int sektor_old;
  432. /* Wektory napiecia falownika */
  433. static double ux[7]={0,p2/p3,p2/(p3*2),-p2/(p3*2),-p2/p3,-p2/(p3*2),p2/(p3*2)};
  434. static double uy[7]={0,0,p2/2,p2/2,0,-p2/2,-p2/2};
  435.  
  436. impuls+=h;
  437.  
  438. if (impuls>Timp)
  439.     {
  440.     if (roU>2*M_PI) roU-=2*M_PI;
  441.     if (roU<0) roU+=2*M_PI;
  442.     NroU=(int)floor(roU/(M_PI/3));
  443.     switch(NroU)
  444.         {
  445.         case 0: idu0a=0; idu1=1; idu2=2; idu0b=7; *sektor=1; break;
  446.         case 1: idu0a=7; idu1=2; idu2=3; idu0b=0; *sektor=2; break;
  447.         case 2: idu0a=0; idu1=3; idu2=4; idu0b=7; *sektor=3; break;
  448.         case 3: idu0a=7; idu1=4; idu2=5; idu0b=0; *sektor=4; break;
  449.         case 4: idu0a=0; idu1=5; idu2=6; idu0b=7; *sektor=5; break;
  450.         case 5: idu0a=7; idu1=6; idu2=1; idu0b=0; *sektor=6; break;
  451.         }
  452.     USX=US*cos(roU); USY=US*sin(roU);
  453.     wt=ux[idu1]*uy[idu2]-uy[idu1]*ux[idu2];
  454.     *t1=Timp*(USX*uy[idu2]-USY*ux[idu2])/(ud*wt);
  455.     *t2=Timp*(-USX*uy[idu1]+USY*ux[idu1])/(ud*wt);
  456.     *t0=Timp-*t1-*t2;
  457.     if (*t0<0.0) *t0=0.0;
  458.     impuls-=Timp;
  459.     if(*sektor==sektor_old) cykl*=-1;
  460.     *SYNCH=1;
  461.     temp=1;
  462.     sektor_old=*sektor;
  463.     }
  464.  
  465. /* wyznaczenie napiecia na wyjsciu falownika */
  466. if (cykl==1)
  467.       {          // cykl: t0/2..t1..t2..t0/2
  468.       if (impuls<=*t0/2) {*usx=0; *usy=0; *wektor=idu0a; if(temp) temp=0; else *SYNCH=0;}
  469.       else if (impuls<=(*t0/2+*t1)) {*usx=ud*ux[idu1]; *usy=ud*uy[idu1]; *wektor=idu1; }
  470.       else if (impuls<=(*t0/2+*t1+*t2)) {*usx=ud*ux[idu2]; *usy=ud*uy[idu2]; *wektor=idu2; }
  471.       else {*usx=0; *usy=0; *wektor=idu0b; }
  472.       }
  473. else
  474.       {          // cykl: t0/2..t2..t1..t0/2
  475.       if (impuls<=*t0/2) {*usx=0; *usy=0; *wektor=idu0b; if(temp) temp=0; else *SYNCH=0;}
  476.       else if (impuls<=(*t0/2+*t2)) {*usx=ud*ux[idu2]; *usy=ud*uy[idu2]; *wektor=idu2; }
  477.       else if (impuls<=(*t0/2+*t2+*t1)) {*usx=ud*ux[idu1]; *usy=ud*uy[idu1]; *wektor=idu1; }
  478.       else {*usx=0; *usy=0; *wektor=idu0a; }
  479.       }
  480. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!