source: branches/gui/eml/controllers/PIDs.mso @ 667

Last change on this file since 667 was 667, checked in by gerson bicca, 14 years ago

fixed controllers/PIDs.mso

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 10.9 KB
Line 
1#*-------------------------------------------------------------------
2* EMSO Model Library (EML) Copyright (C) 2004 - 2007 ALSOC.
3*
4* This LIBRARY is free software; you can distribute it and/or modify
5* it under the therms of the ALSOC FREE LICENSE as available at
6* http://www.enq.ufrgs.br/alsoc.
7*
8* EMSO Copyright (C) 2004 - 2007 ALSOC, original code
9* from http://www.rps.eng.br Copyright (C) 2002-2004.
10* All rights reserved.
11*
12* EMSO is distributed under the therms of the ALSOC LICENSE as
13* available at http://www.enq.ufrgs.br/alsoc.
14*--------------------------------------------------------------------
15* Author: Tiago Osório
16* $Id: PIDs.mso 667 2008-10-20 19:40:50Z bicca $
17*-------------------------------------------------------------------*#
18using "types";
19
20Model MPorts
21
22ATTRIBUTES
23        Pallete         = false;
24        Brief           = "Model of Ports to be used with PIDs.";
25       
26        VARIABLES
27       
28        input      as control_signal (Brief="Previous scaled input signal", Default=0.5);
29        output     as control_signal (Brief="Scaled output signal", Default=0.5);
30        setPoint   as control_signal (Brief="Scaled setPoint",Default=0.5);
31
32end
33
34Model MInternal_Variables
35       
36        ATTRIBUTES
37        Pallete         = false;
38        Brief           = "Model of Internal Variables to be used with PIDs.";
39       
40        VARIABLES
41
42        derivTerm  as control_signal (Brief="Derivative term", Default=0);
43        dFilt      as control_signal (Brief="Derivative term filtered", Default=0.5);
44        error      as control_signal (Brief="Error definition for proportional term");
45        errorD     as control_signal (Brief="Error definition for derivative term");
46        errorI     as control_signal (Brief="Error definition for integral term");
47        inputFilt  as control_signal (Brief="Filtered input");
48        intTerm    as control_signal (Brief="Integral term", Default=0);
49        outp       as control_signal (Brief="Sum of proportional, integral and derivative terms");
50        outps      as control_signal (Brief="Variable outp scaled between -1 and 1");
51        propTerm   as control_signal (Brief="Proportional term", Default=0);
52        setPointFilt  as control_signal (Brief="Filtered setPoint", Default=0);
53
54end
55
56Model PID
57
58ATTRIBUTES
59        Pallete         = false;
60        Icon            = "icon/PID";
61        Brief           = "Model of PIDs.";
62        Info            =
63"== Inputs ==
64* scaled processs variable.
65* scaled bias.
66* scaled setpoint.
67
68== Outputs ==
69* scaled output.
70";
71       
72        PARAMETERS
73        PID_Select as Switcher (Brief="Type of PID Incremental", Valid=["Ideal","Parallel","Series","Ideal_AWBT","Parallel_AWBT","Series_AWBT","Ideal_AW","Parallel_AW","Series_AW"], Default = "Ideal");
74        Action     as Switcher (Brief="Controller action", Valid=["Direct","Reverse"], Default = "Reverse");
75        Mode       as Switcher (Brief="Controller mode", Valid=["Automatic","Manual"], Default = "Automatic");
76        Clip       as Switcher (Brief="Controller mode", Valid=["Clipped","Unclipped"], Default = "Clipped");
77
78        alpha      as positive (Brief="Derivative term filter constant", Default=1);
79        beta       as positive (Brief="Proportional term setPoint change filter");
80        bias       as control_signal (Brief="Previous scaled bias", Default=0.5);
81        derivTime  as time_sec (Brief="Derivative time constant");
82        intTime    as time_sec (Brief="Integral time constant");
83        gain       as positive (Brief="Controller gain", Default=0.5);
84        gamma      as positive (Brief="Derivative term SP change filter");
85        tau        as time_sec (Brief="Input filter time constant");
86        tauSet     as time_sec (Brief="Input filter time constant");
87       
88        VARIABLES
89        Internal           as MInternal_Variables;
90        Ports              as MPorts;
91        AWFactor     as Real     (Brief="Integral term multiplier used in anti-reset windup");
92        action       as Real(Protected=true);
93       
94        INITIAL
95        Internal.intTerm = 0;
96        diff(Internal.dFilt) = 0/'s';
97        diff(Internal.inputFilt) = 0/'s';
98        diff(Internal.setPointFilt) = 0/'s';
99       
100        EQUATIONS
101
102        if (tau equal 0) then
103                "Input first order filter"
104                (tau + 1e-3*'s')*diff(Internal.inputFilt)= Ports.input - Internal.inputFilt;
105        else
106                "Input first order filter"
107                tau*diff(Internal.inputFilt)= Ports.input - Internal.inputFilt;
108        end
109
110        if (tauSet equal 0) then
111                "setPoint first order filter"
112                (tauSet + 1e-3*'s')*diff(Internal.setPointFilt)= Ports.setPoint - Internal.setPointFilt;
113        else
114                "setPoint first order filter"
115                tauSet*diff(Internal.setPointFilt)= Ports.setPoint - Internal.setPointFilt;
116        end
117       
118        switch Mode
119        case "Manual":
120                "Error definition for proportional term"
121                Internal.error = Internal.inputFilt*(beta-1.0);
122                "Error definition for derivative term"
123                Internal.errorD= Internal.inputFilt*(gamma-1.0);
124                "Error definition for integral term"           
125                Internal.errorI= 0;
126        case "Automatic":
127                "Error definition for proportional term"                       
128                Internal.error = beta*Internal.setPointFilt - Internal.inputFilt;
129                "Error definition for derivative term"
130                Internal.errorD = gamma*Internal.setPointFilt - Internal.inputFilt;
131                "Error definition for integral term"
132                Internal.errorI = Internal.setPointFilt-Internal.inputFilt;
133        end
134       
135        "Calculate proportional term"
136        Internal.propTerm=Internal.error;
137       
138        if (derivTime equal 0) then
139                "Derivative term filter"       
140                alpha*(derivTime + 1e-3*'s')*diff(Internal.dFilt) = Internal.errorD - Internal.dFilt;
141        else
142                "Derivative term filter"       
143                alpha*(derivTime)*diff(Internal.dFilt) = Internal.errorD - Internal.dFilt;
144        end
145
146        "Calculate derivative term"
147        Internal.derivTerm = derivTime*diff(Internal.dFilt);
148       
149        "Scale outp"
150        Internal.outps=2*Internal.outp-1;
151       
152        switch Clip
153        case "Clipped":
154                if abs(Internal.outps)>1 then
155                        "Calculate clipped output when it´s saturated"
156                        Ports.output=(sign(Internal.outps)*1+1)/2;
157                else
158                        "Calculate clipped output when it´s not saturated"
159                        Ports.output=Internal.outp;
160                end
161        case "Unclipped":
162                "Calculate unclipped output"
163                Ports.output=Internal.outp;
164        end
165
166        switch Action
167        case "Direct":
168                action = -1.0;
169        case "Reverse":
170                action = 1.0;
171        end
172
173
174switch PID_Select
175       
176case "Ideal_AW":
177       
178        "Calculate integral term with anti-windup"
179        intTime*diff(Internal.intTerm) = AWFactor*Internal.errorI;
180       
181        "Sum of proportional, integral and derivative terms"
182        Internal.outp = bias + action*gain*(Internal.propTerm + Internal.intTerm + Internal.derivTerm);
183
184        if abs(Internal.outps)>1 and (action*sign(Internal.outps)*Internal.errorI)>0 then
185                "Calculate AWFactor"
186                AWFactor=-tanh(sign(Internal.outps)*Internal.outps*100-102);
187        else
188                "Calculate AWFactor"
189                AWFactor=1;
190        end
191
192case "Parallel_AW":
193       
194        "Calculate integral term with anti-windup"
195        intTime*diff(Internal.intTerm) = AWFactor*Internal.errorI;
196       
197        "Sum of proportional, integral and derivative terms"
198        Internal.outp = bias + action*(gain*Internal.propTerm + Internal.intTerm + Internal.derivTerm);
199
200        if abs(Internal.outps)>1 and (action*sign(Internal.outps)*Internal.errorI)>0 then
201                "Calculate AWFactor"
202                AWFactor=-tanh(sign(Internal.outps)*Internal.outps*100-102);
203        else
204                "Calculate AWFactor"
205                AWFactor=1;
206        end
207
208
209case "Series_AW":
210
211        "Calculate integral term with anti-windup"     
212        intTime*diff(Internal.intTerm) = AWFactor*Internal.errorI;
213       
214        "Sum of proportional, integral and derivative terms"
215        Internal.outp = bias + action*(gain*(Internal.propTerm + Internal.intTerm)*(1 + Internal.derivTerm));
216
217        if abs(Internal.outps)>1 and (action*sign(Internal.outps)*Internal.errorI)>0 then
218                "Calculate AWFactor"           
219                AWFactor=-tanh(sign(Internal.outps)*Internal.outps*100-102);
220        else
221                "Calculate AWFactor"
222                AWFactor=1;
223        end
224
225case "Ideal":
226       
227        "Calculate integral term"       
228        intTime*diff(Internal.intTerm) = Internal.errorI;
229       
230        "Sum of proportional, integral and derivative terms"   
231        Internal.outp = bias + action*gain*(Internal.propTerm + Internal.intTerm + Internal.derivTerm);
232
233        "Calculate AWFactor - Not in use in this mode"
234        AWFactor=1;
235       
236case "Parallel":
237       
238        "Calculate integral term"       
239        intTime*diff(Internal.intTerm) = Internal.errorI;
240       
241        "Sum of proportional, integral and derivative terms"   
242        Internal.outp = bias + action*(gain*Internal.propTerm + Internal.intTerm + Internal.derivTerm);
243
244        "Calculate AWFactor - Not in use in this mode"
245        AWFactor=1;
246       
247case "Series":
248       
249        "Calculate integral term"       
250        intTime*diff(Internal.intTerm) = Internal.errorI;
251       
252        "Sum of proportional, integral and derivative terms"
253        Internal.outp = bias + action*(gain*(Internal.propTerm + Internal.intTerm)*(1 + Internal.derivTerm));
254       
255        "Calculate AWFactor - Not in use in this mode"
256        AWFactor=1;
257       
258case "Ideal_AWBT":
259       
260        "Calculate integral term with anti-windup and bumpless transfer"       
261        action*gain*(intTime*diff(Internal.intTerm)-Internal.errorI) = Ports.output-Internal.outp;     
262       
263        "Sum of proportional, integral and derivative terms"   
264        Internal.outp = bias + action*gain*(Internal.propTerm + Internal.intTerm + Internal.derivTerm);
265       
266        "Calculate AWFactor - Not in use in this mode"
267        AWFactor=1;
268       
269case "Parallel_AWBT":
270       
271        "Calculate integral term with anti-windup and bumpless transfer"       
272        action*gain*(intTime*diff(Internal.intTerm)-Internal.errorI) = Ports.output-Internal.outp;     
273       
274        "Sum of proportional, integral and derivative terms"   
275        Internal.outp = bias + action*(gain*Internal.propTerm + Internal.intTerm + Internal.derivTerm);
276       
277        "Calculate AWFactor - Not in use in this mode"
278        AWFactor=1;
279       
280case "Series_AWBT":
281       
282        "Calculate integral term with anti-windup and bumpless transfer"
283        action*gain*(intTime*diff(Internal.intTerm)-Internal.errorI) = Ports.output-Internal.outp;     
284       
285        "Sum of proportional, integral and derivative terms"
286        Internal.outp = bias + action*(gain*(Internal.propTerm + Internal.intTerm)*(1 + Internal.derivTerm));
287
288        "Calculate AWFactor - Not in use in this mode"
289        AWFactor=1;
290       
291end
292
293end
294
295
296Model PID_gui as PID
297
298        ATTRIBUTES
299        Pallete         = true;
300        Icon            = "icon/PID";
301
302        PARAMETERS
303        MinInput as control_signal(Default=-1000);
304        MaxInput as control_signal(Default=1000);
305        MinOutput as control_signal(Default=-1000);
306        MaxOutput as control_signal(Default=1000);
307       
308        VARIABLES
309in      Input as control_signal(Protected=true, PosX=0, PosY=0.5);
310out     Output as control_signal(Protected=true, PosX=0.7, PosY=1);
311        SetPoint as control_signal;
312       
313        EQUATIONS
314        Ports.input*(MaxInput - MinInput) = Input - MinInput;
315        "Output ??????"
316        Output = Ports.output*(MaxOutput-MinOutput) +MinOutput;
317        Ports.setPoint*(MaxInput - MinInput) = SetPoint - MinInput;
318
319end
320
321Model FirstOrder
322        ATTRIBUTES
323        Pallete         = true;
324        Icon            = "icon/PIDIncr";
325
326        PARAMETERS
327        tau    as Real (Brief="Time Constant", Unit = 's', Default=4);
328        A      as Real (Unit='1/s');
329        B      as Real (Unit='1/s');
330        C      as Real;
331        D      as Real(Default=0);
332
333        VARIABLES
334        x as control_signal(Brief="State");
335in      u as control_signal(Brief="Input signal", PosX=0, PosY=0.5);
336out     y as control_signal(Brief="Output signal", PosX=1, PosY=0.5);
337
338        EQUATIONS
339        diff(x) = A*x + B*u;
340        y = C*x + D*u;
341end
342
343
344Model StepSignal
345        ATTRIBUTES
346        Pallete         = true;
347        Icon            = "icon/StepSignal";
348
349        PARAMETERS
350        StepTime as positive(Unit='s');
351        StartValue as control_signal;
352        FinalValue as control_signal;
353       
354        VARIABLES
355out     OutSignal as control_signal(PosX=1, PosY=0.5);
356
357        EQUATIONS
358        if(time < StepTime) then
359                OutSignal = StartValue;
360        else
361                OutSignal = FinalValue;
362        end
363end
364
365Model ConstantSignal
366        ATTRIBUTES
367        Pallete         = true;
368        Icon            = "icon/ConstSignal";
369
370        PARAMETERS
371        Value as control_signal;
372       
373        VARIABLES
374out     OutSignal as control_signal(PosX=1, PosY=0.5);
375
376        EQUATIONS
377        OutSignal = Value;
378end
Note: See TracBrowser for help on using the repository browser.