|
3397
|
1 ## Copyright (C) 1996, 1998 Auburn University. All rights reserved. |
|
3381
|
2 ## |
|
|
3 ## This file is part of Octave. |
|
|
4 ## |
|
|
5 ## Octave is free software; you can redistribute it and/or modify it |
|
|
6 ## under the terms of the GNU General Public License as published by the |
|
|
7 ## Free Software Foundation; either version 2, or (at your option) any |
|
|
8 ## later version. |
|
|
9 ## |
|
|
10 ## Octave is distributed in the hope that it will be useful, but WITHOUT |
|
|
11 ## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
12 ## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
13 ## for more details. |
|
|
14 ## |
|
|
15 ## You should have received a copy of the GNU General Public License |
|
|
16 ## along with Octave; see the file COPYING. If not, write to the Free |
|
|
17 ## Software Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. |
|
3346
|
18 |
|
|
19 ## -*- texinfo -*- |
|
|
20 ## @deftypefn {Function File } {} sysrepdemo |
|
|
21 ## Tutorial for the use of the system data structure functions. |
|
|
22 ## @end deftypefn |
|
3213
|
23 |
|
3381
|
24 ## Octave Controls toolbox demo: System representation |
|
|
25 ## Written by A. S. Hodel June 1995 |
|
|
26 ## Revised Aug 1995 for system data structure format |
|
3397
|
27 |
|
3385
|
28 function sysrepdemo () |
|
3346
|
29 |
|
3213
|
30 save_val = page_screen_output; |
|
|
31 page_screen_output = 1; |
|
|
32 |
|
|
33 disp('System representation demo:') |
|
3386
|
34 num = [5, -1]; |
|
|
35 denom = [1, -2, 6]; |
|
3213
|
36 a = b = c = []; |
|
|
37 syschoice = -1; |
|
|
38 ch_init = 2; |
|
|
39 ch_extract = ch_init+1; |
|
|
40 ch_update = ch_extract+1; |
|
|
41 ch_view = ch_update+1; |
|
|
42 ch_details = ch_view+1; |
|
|
43 ch_quit = ch_details+1; |
|
|
44 while(syschoice != ch_quit) |
|
|
45 disp(" ") |
|
|
46 syschoice = menu('Octave System Representation Menu', ... |
|
|
47 "General overview of system representation (DO THIS FIRST)", ... |
|
|
48 "Initialize a system (ss2sys, tf2sys, zp2sys)", ... |
|
3228
|
49 "Extract data from a system(sys2ss, sys2tf, sys2zp, etc.)", ... |
|
3213
|
50 "Update internal representation (sysupdate)", ... |
|
|
51 "View the internal contents of a system (sysout)", ... |
|
|
52 "Details of internal representation", ... |
|
|
53 "Return to main menu"); |
|
|
54 if(syschoice == 1) # general overview |
|
|
55 disp("The Octave Control Systems Toolbox (OCST) was designed to") |
|
|
56 disp("provide a simple user interface to a powerful set of tools.") |
|
|
57 disp(' ') |
|
|
58 disp(' ----------') |
|
|
59 disp(' input(s) ---->| System | ---> output(s) ') |
|
|
60 disp(' ----------') |
|
|
61 disp(' ') |
|
|
62 disp("Like other computer-aided control system design tools, the OCST") |
|
|
63 disp("enables users to enter their descriptions of dynamic systems in ") |
|
|
64 disp("their preferred form (state space, transfer function, or "); |
|
|
65 disp("zero-pole format). "); |
|
|
66 disp("The OCST stores system descriptions in a single variable data "); |
|
|
67 disp("structure that allows for continuous time, discrete-time, or mixed "); |
|
|
68 disp("(sampled-data) systems. "); |
|
|
69 disp(" "); |
|
|
70 disp("This single variable description of dynamic systems greatly simplifies "); |
|
|
71 disp("both the code of the OCST as well as the user interface, since only") |
|
|
72 disp("one variable is passed per system, regardless of the internal ") |
|
|
73 disp("representation used in the data structure. As a result, the "); |
|
|
74 disp("likelihood of user error is greatly reduced when calling OCST") |
|
|
75 disp("functions. Further, all OCST functions have been written to") |
|
|
76 disp("provide meaningful warning or error message to assist the user") |
|
|
77 disp("in correcting their programming errors while using the OCST.") |
|
|
78 disp("The details of the internal representation can be seen in "); |
|
|
79 disp(["menu option ",num2str(ch_details)]); |
|
|
80 disp("The data structure used in the OCST is called a \"system data structure.\""); |
|
|
81 disp("A system data structure is contstructed with one of:") |
|
|
82 disp(" fir2sys (FIR transfer function to system)") |
|
|
83 disp(" ss2sys (state space matrices to system)") |
|
|
84 disp(" tf2sys (SISO transfer function to system)") |
|
|
85 disp(" zp2sys (SISO zero/pole/leading coefficient to system)") |
|
|
86 disp(" ") |
|
|
87 disp(["These functions are discussed in in menu option ",num2str(ch_init)]) |
|
|
88 disp("The data in a system may be extracted using ") |
|
|
89 disp(" sys2fir (FIR transfer function from system") |
|
|
90 disp(" sys2ss (state space matrices from system)") |
|
|
91 disp(" sys2tf (SISO transfer function from system)") |
|
|
92 disp(" sys2zp (SISO zero/pole/leading coefficient from system)") |
|
|
93 disp(" ") |
|
|
94 disp(["These functions are discussed in menu option ", ... |
|
|
95 num2str(ch_extract)]); |
|
|
96 disp("Other options discussed under this menu are updating the internal") |
|
|
97 disp("representation form of a system data structure with sysupdate and printing") |
|
|
98 disp("the description of a dynamic system to the screen with sysout.") |
|
|
99 disp(" ") |
|
|
100 disp("Once the user is familiar with these commands, the rest of the ") |
|
|
101 disp("OCST package will be quite easy to use.") |
|
|
102 elseif(syschoice == ch_init) % Initialize |
|
|
103 disp("Initialization of a system:"); |
|
|
104 disp(' '); |
|
|
105 formopt = 0; |
|
|
106 while(formopt != 4) |
|
|
107 disp("Three data formats may be used to initialize a system:") |
|
|
108 formopt = menu("System data structure initialization menu", ... |
|
|
109 "State space form (ss2sys)", ... |
|
|
110 "Transfer function form (tf2sys)", ... |
|
|
111 "zero-pole form (zp2sys)", ... |
|
|
112 "Return to System representation menu"); |
|
|
113 if(formopt == 1) |
|
|
114 disp('State space representation of a system is based on the usual') |
|
|
115 disp('multi-variable differential equations') |
|
|
116 disp(' ') |
|
|
117 disp(' . ') |
|
|
118 disp(' x = A x + B u -or - x(k+1) = A x(k) + B u(k) ') |
|
|
119 disp(' y = C x + D u y(k) = C x(k) + D u(k) ') |
|
|
120 disp(' ') |
|
|
121 disp('for matrices A, B, C, D of appropriate dimension.') |
|
|
122 disp(' ') |
|
|
123 ssopt = 0; |
|
|
124 ssquit = 5; |
|
|
125 while(ssopt < ssquit) |
|
|
126 ssopt = menu("State space initialization examples", ... |
|
|
127 "Double integrator example", ... |
|
|
128 "Double delay (discrete-time) example", ... |
|
|
129 "Summing junction (D-matrix only) example", ... |
|
|
130 "ss2sys details (help ss2sys)", ... |
|
|
131 "return to system initialization menu", ... |
|
|
132 "return to system representation main menu"); |
|
|
133 if(ssopt == 1) |
|
|
134 disp("Example: construct a system representation of a") |
|
|
135 disp("double integrator via state-space form") |
|
3386
|
136 cmd = "a = [0, 1; 0, 0];"; |
|
3213
|
137 run_cmd |
|
3386
|
138 cmd = "b = [0; 1];"; |
|
3213
|
139 run_cmd |
|
3386
|
140 cmd = "c = [1, 0];"; |
|
3213
|
141 run_cmd |
|
|
142 cmd = "sys = ss2sys(a,b,c);"; |
|
|
143 run_cmd |
|
|
144 disp("The state space form of the system is seen via sysout:") |
|
|
145 cmd = "sysout(sys)"; |
|
|
146 run_cmd |
|
|
147 disp("Notice that the Octave controls toolbox automatically") |
|
|
148 disp("assigns names to the states, inputs and outputs,") |
|
|
149 disp("and that the D matrix was filled in automatically.") |
|
|
150 disp("We verify that it's a double integrator via sysout:") |
|
|
151 cmd = "sysout(sys,""tf"")"; |
|
|
152 run_cmd |
|
|
153 prompt |
|
|
154 elseif(ssopt == 2) |
|
|
155 disp("Example: discrete-time double-delay:") |
|
|
156 disp("This example is identical to the double-integrator,") |
|
|
157 disp("except that it is a discrete-time system, and so has") |
|
|
158 disp("a sampling interval. We arbitrarily select T=1e-3."); |
|
3386
|
159 cmd = "a = [0, 1; 0, 0];"; |
|
3213
|
160 run_cmd |
|
3386
|
161 cmd = "b = [0; 1];"; |
|
3213
|
162 run_cmd |
|
3386
|
163 cmd = "c = [1, 0];"; |
|
3213
|
164 run_cmd |
|
|
165 cmd = "sys=ss2sys(a,b,c,[],1e-3);"; |
|
|
166 run_cmd |
|
|
167 cmd = "sysout(sys)"; |
|
|
168 run_cmd |
|
|
169 disp("Notice that the D matrix was filled in automatically.") |
|
|
170 disp("This is done if D is input as the empty matrix.") |
|
|
171 disp(" ") |
|
|
172 disp("Notice also that the output y_1 is labelled as a discrete") |
|
|
173 disp("output. The OCST data structure keeps track of states") |
|
|
174 disp("and output signals that are produced by the discrete-time") |
|
|
175 disp("portion of a system. Discrete states and outputs are ") |
|
|
176 disp("implemented as shown in the block diagram below:") |
|
|
177 disp(" ") |
|
|
178 disp(" ") |
|
|
179 disp(" _________ ________ x(kT) ________________") |
|
|
180 disp("f(t)-->|sampler|-->| delay |----->|zero order hold| -->") |
|
|
181 disp(" --------- -------- ----------------") |
|
|
182 disp(" ") |
|
|
183 disp(" ___________ _______________") |
|
|
184 disp("f(t)-->| sampler |-->|zero-order hold| --> y(discrete)") |
|
|
185 disp(" ----------- ---------------") |
|
|
186 disp(" ") |
|
|
187 disp("where f(t) is an input signal to either the output or the") |
|
|
188 disp(" discrete state.") |
|
|
189 disp(" ") |
|
|
190 disp("The OCST does not implement samplers on inputs to continuous") |
|
|
191 disp("time states (i.e., there are no samplers implicit in the B") |
|
|
192 disp("or D matrices unless there are corresponding discrete") |
|
|
193 disp("outputs or states. The OCST provides warning messages when") |
|
|
194 disp("if this convention is violated.") |
|
|
195 prompt |
|
|
196 elseif(ssopt == 3) |
|
|
197 disp("A summing junction that computes e(t) = r(t) - y(t) may be"); |
|
|
198 disp("constructed as follows:"); |
|
|
199 disp("First, we set the matrix D:") |
|
3386
|
200 cmd = "D = [1, -1];"; |
|
3213
|
201 run_cmd |
|
|
202 disp("ss2sys allows the initialization of signal and state names") |
|
|
203 disp("(see option 4), so we initialize these as follows:") |
|
3228
|
204 cmd = "inname = list(\"r(t)\",\"y(t)\");"; |
|
3213
|
205 run_cmd; |
|
|
206 cmd = "outname = \"e(t)\";"; |
|
|
207 run_cmd |
|
|
208 disp("Since the system is continous time and without states,") |
|
|
209 disp("the ss2sys inputs tsam, n, and nz are all zero:") |
|
|
210 cmd = "sys = ss2sys([],[],[],D,0,0,0,[],inname,outname);"; |
|
|
211 run_cmd |
|
|
212 disp("The resulting system is:") |
|
|
213 cmd = "sysout(sys)"; |
|
|
214 run_cmd |
|
|
215 disp("A discrete-time summing block can be implemented by setting") |
|
|
216 disp("the sampling time positive:") |
|
|
217 cmd = "sys = ss2sys([],[],[],D,1e-3,0,0,[],inname,outname);"; |
|
|
218 run_cmd |
|
|
219 disp("The resulting system is:") |
|
|
220 cmd = "sysout(sys)"; |
|
|
221 run_cmd |
|
|
222 prompt |
|
|
223 elseif(ssopt == 4) |
|
|
224 help ss2sys |
|
|
225 disp(" ") |
|
|
226 disp(" ") |
|
|
227 disp("Notice that state-space form allows a single system to have") |
|
|
228 disp("both continuous and discrete-time states and to have both continuous") |
|
|
229 disp("and discrete-time outputs. Since it's fairly easy to make an") |
|
|
230 disp("error when mixing systems of this form, the Octave controls") |
|
|
231 disp("toolbox attempts to print warning messages whenever something") |
|
|
232 disp("questionable occurs.") |
|
|
233 elseif(ssopt == 6) |
|
|
234 formopt = 4; # return to main menu |
|
|
235 endif |
|
|
236 endwhile |
|
|
237 elseif(formopt == 2) |
|
|
238 tfopt = 0; |
|
|
239 while(tfopt < 5) |
|
|
240 tfopt = menu("Transfer function initialization menu", ... |
|
|
241 "Continuous time initialization" , ... |
|
|
242 "Discrete time initialization" , ... |
|
|
243 "User specified signal names" , ... |
|
|
244 "tf2sys details (help tf2sys)", ... |
|
|
245 "Return to system initialization menu", ... |
|
|
246 "Return to system representation main menu"); |
|
|
247 if(tfopt == 1) # continuous time |
|
|
248 disp("A transfer function is represented by vectors of the") |
|
|
249 disp("coefficients of the numerator and denominator polynomials"); |
|
|
250 disp(" ") |
|
|
251 disp("For example: the transfer function"); |
|
|
252 disp(" "); |
|
3386
|
253 num = [5, -1]; |
|
|
254 denom = [1, -2, 6]; |
|
3213
|
255 tfout(num,denom); |
|
|
256 disp(" ") |
|
|
257 disp("is generated by the following commands:") |
|
3386
|
258 cmd = "num = [5, -1]"; |
|
3213
|
259 run_cmd |
|
3386
|
260 cmd = "denom = [1, -2, 6]"; |
|
3213
|
261 run_cmd |
|
|
262 cmd = "sys = tf2sys(num,denom);"; |
|
|
263 run_cmd |
|
|
264 disp("alternatively, the system can be generated in a single command:"); |
|
3386
|
265 cmd = "sys = tf2sys([5, -1], [1, -2, 6]);"; |
|
3213
|
266 run_cmd |
|
|
267 disp("Notice the output of sys: it is an Octave data structure.") |
|
|
268 disp("The details of its member variables are explained under") |
|
|
269 disp("System Representation Menu option 5 (the details of system form)") |
|
|
270 disp(" "); |
|
|
271 disp("The data structure can be observed with the sysout command:") |
|
|
272 cmd = "sysout(sys)"; |
|
|
273 run_cmd |
|
|
274 disp("Notice that Octave assigns names to inputs and outputs.") |
|
|
275 disp("The user may manually select input and output names; see option 3"); |
|
|
276 prompt |
|
|
277 elseif(tfopt == 2) # discrete time |
|
|
278 disp("A transfer function is represented by vectors of the") |
|
|
279 disp("coefficients of the numerator and denominator polynomials"); |
|
|
280 disp("Discrete-time transfer functions require ") |
|
|
281 disp("the additional parameter of a sampling period:") |
|
3386
|
282 cmd = "sys=tf2sys([5, -1], [1, 2, -6], 1e-3);"; |
|
3213
|
283 run_cmd |
|
|
284 cmd = "sysout(sys)"; |
|
|
285 run_cmd |
|
|
286 disp("The OCST recognizes discrete-time transfer functions and") |
|
|
287 disp("accordingly prints them with the frequency domain variable z."); |
|
|
288 disp("Notice that Octave assigns names to inputs and outputs.") |
|
|
289 disp("The user may set input and output names; see option 3"); |
|
|
290 elseif(tfopt == 3) # user specified names |
|
|
291 disp("The OCST requires all signals to have names. The OCST assigned default"); |
|
|
292 disp("names to the signals in the other examples. We may initialize a transfer"); |
|
|
293 disp("function with user-specified names as follows: Consider a simple ") |
|
|
294 disp("double-integrator model of aircraft roll dynamics with ") |
|
|
295 disp("input \"aileron angle\" and output \"theta\". A ") |
|
|
296 disp("system for this model is generated by the command") |
|
3386
|
297 cmd = "aircraft=tf2sys(1, [1, 0, 0], 0,\"aileron angle\",\"theta\");"; run_cmd |
|
3213
|
298 disp("The sampling time parameter 0 indicates that the system") |
|
|
299 disp("is continuous time. A positive sampling time indicates a") |
|
|
300 disp("discrete-time system (or sampled data system).") |
|
|
301 cmd = "sysout(aircraft)"; |
|
|
302 run_cmd |
|
|
303 disp("Notice that the user-selected signal names are listed.") |
|
|
304 disp("These signal names are used in OCST plots and design functions."); |
|
|
305 disp("(Run the frequency response demo to see an example of the use of "); |
|
|
306 disp("signal names in plots.)") |
|
|
307 prompt |
|
|
308 elseif(tfopt == 4) # help |
|
|
309 help tf2sys |
|
|
310 prompt |
|
|
311 elseif(tfopt == 6) # return to main menu |
|
|
312 formopt = 4; |
|
|
313 endif |
|
|
314 endwhile |
|
|
315 elseif (formopt == 3) |
|
|
316 zpopt = 0; |
|
|
317 while(zpopt < 5) |
|
|
318 zpopt = menu("Zero-pole initialization menu", ... |
|
|
319 "Continuous time initialization" , ... |
|
|
320 "Discrete time initialization" , ... |
|
|
321 "User specified signal names" , ... |
|
|
322 "zp2sys details (help zp2sys)", ... |
|
|
323 "Return to system initialization menu", ... |
|
|
324 "Return to system representation main menu"); |
|
|
325 if(zpopt == 1) # continuous time |
|
|
326 disp("A zero-pole form representation of a system includes vectors") |
|
|
327 disp("of the system poles and zeros and a scalar leading coefficient."); |
|
|
328 disp(" ") |
|
|
329 disp("For example: the transfer function"); |
|
|
330 disp(" "); |
|
|
331 k = 5; |
|
3386
|
332 num = [5, -1]; |
|
|
333 denom = [1, -2, 6]; |
|
3213
|
334 zpout(num,denom,k); |
|
|
335 disp(" ") |
|
|
336 disp("is generated by the following commands:") |
|
3386
|
337 cmd = "num = [5, -1]"; |
|
3213
|
338 run_cmd |
|
3386
|
339 cmd = "denom = [1, -2, 6]"; |
|
3213
|
340 run_cmd |
|
|
341 cmd = "k = 5"; |
|
|
342 run_cmd |
|
|
343 cmd = "sys = zp2sys(num,denom,k);"; |
|
|
344 run_cmd |
|
|
345 disp("alternatively, the system can be generated in a single command:"); |
|
3386
|
346 cmd = "sys = zp2sys([5, -1],[1, -2, 6],5);"; |
|
3213
|
347 run_cmd |
|
|
348 disp("Notice the output of sys: it is an Octave data structure.") |
|
|
349 disp("The details of its member variables are explained under") |
|
|
350 disp("System Representation Menu option 5 (the details of system form)") |
|
|
351 disp(" "); |
|
|
352 disp("The data structure can be observed with the sysout command:") |
|
|
353 cmd = "sysout(sys)"; |
|
|
354 run_cmd |
|
|
355 disp("Notice that Octave assigns names to inputs and outputs.") |
|
|
356 disp("The user may manually select input and output names; see option 3"); |
|
|
357 prompt |
|
|
358 elseif(zpopt == 2) # discrete time |
|
|
359 disp("A zero-pole form representation of a system includes vectors") |
|
|
360 disp("of the system poles and zeros and a scalar leading coefficient."); |
|
|
361 disp(" ") |
|
|
362 disp("Discrete-time systems require the additional parameter of a sampling period:") |
|
3386
|
363 cmd = "sys=zp2sys([5, -1],[1, 2, -6],5,1e-3);"; |
|
3213
|
364 run_cmd |
|
|
365 cmd = "sysout(sys)"; |
|
|
366 run_cmd |
|
|
367 disp("The OCST recognizes discrete-time transfer functions and") |
|
|
368 disp("accordingly prints them with the frequency domain variable z."); |
|
|
369 disp("Notice that Octave assigns names to inputs and outputs.") |
|
|
370 disp("The user may set input and output names; see option 3"); |
|
|
371 elseif(zpopt == 3) # user specified names |
|
|
372 disp("The OCST requires all signals to have names. The OCST assigned default"); |
|
|
373 disp("names to the signals in the other examples. We may initialize a transfer"); |
|
|
374 disp("function with user-specified names as follows: Consider a simple ") |
|
|
375 disp("double-integrator model of aircraft roll dynamics with ") |
|
|
376 disp("input \"aileron angle\" and output \"theta\". A ") |
|
|
377 disp("system for this model is generated by the command") |
|
3386
|
378 cmd = "aircraft=zp2sys([],[0, 0],1,0,\"aileron angle\",\"theta\");"; run_cmd |
|
3213
|
379 disp("The sampling time parameter 0 indicates that the system") |
|
|
380 disp("is continuous time. A positive sampling time indicates a") |
|
|
381 disp("discrete-time system (or sampled data system).") |
|
|
382 cmd = "sysout(aircraft)"; |
|
|
383 run_cmd |
|
|
384 disp("Notice that the user-selected signal names are listed.") |
|
|
385 disp("These signal names are used in OCST plots and design functions."); |
|
|
386 disp("(Run the frequency response demo to see an example of the use of "); |
|
|
387 disp("signal names in plots.)") |
|
|
388 prompt |
|
|
389 elseif(zpopt == 4) # help |
|
|
390 help zp2sys |
|
|
391 prompt |
|
|
392 elseif(zpopt == 6) # return to main menu |
|
|
393 formopt = 4; |
|
|
394 endif |
|
|
395 endwhile |
|
|
396 endif |
|
|
397 endwhile |
|
|
398 elseif(syschoice == ch_extract) # extract system information |
|
|
399 disp("Extract information from a system data structure in a selected format:") |
|
|
400 disp("The actions of operations ss2sys, tf2sys, and zp2sys are reversed by") |
|
|
401 disp("respective functions sys2ss, sys2tf, and sys2zp. The latter two"); |
|
|
402 disp("functions are applicable only to SISO systems.") |
|
|
403 formopt = 0; |
|
3228
|
404 while(formopt != 8) |
|
3213
|
405 formopt = menu("Extract system information", ... |
|
|
406 "in state space form (sys2ss)", ... |
|
|
407 "in transfer function form (sys2tf)", ... |
|
|
408 "in zero pole form (sys2zp)", ... |
|
3228
|
409 "signal names (sysgetsignals,syssetsignals)", ... |
|
|
410 "sampling time (sysgettsam)", ... |
|
|
411 "signal dimensions (sysdimensions)", ... |
|
|
412 "primary system type (sysgettype)", ... |
|
3213
|
413 "Return to system representation menu"); |
|
|
414 if(formopt == 1) |
|
|
415 help sys2ss |
|
|
416 elseif(formopt == 2) |
|
|
417 help sys2tf |
|
|
418 elseif(formopt == 3) |
|
|
419 help sys2zp |
|
3228
|
420 elseif(formopt == 4) |
|
|
421 help sysgetsignals |
|
|
422 cmd="sys=ss2sys(rand(4),rand(4,2),rand(3,4));"; |
|
|
423 run_cmd |
|
|
424 printf("Example: All signals names can be extracted by\n"); |
|
|
425 cmd = "[Ast,Ain,Aout,Ayd] = sysgetsignals(sys)"; |
|
|
426 run_cmd |
|
|
427 printf("Example: Input signal names can be extracted as\n"); |
|
|
428 cmd = "Ain = sysgetsignals(sys,\"in\")"; |
|
|
429 run_cmd |
|
|
430 printf("Example: The name of output signal 2 can be extracted as\n"); |
|
|
431 cmd = "Aout = sysgetsignals(sys,\"out\",2)"; |
|
|
432 run_cmd |
|
|
433 printf("\nNotice that Aout is returned as a list; the signal name\n"); |
|
|
434 printf("itself is obtained by specifying the input parameter strflg\n"); |
|
|
435 cmd = "Aout = sysgetsignals(sys,\"out\",2,1)"; |
|
|
436 run_cmd |
|
|
437 prompt |
|
|
438 cmd = "help syssetsignals"; |
|
|
439 run_cmd |
|
|
440 printf("Example: set input 2 name to \"motor voltage\"\n"); |
|
|
441 cmd = "sys = syssetsignals(sys,\"in\",\"motor voltage\",2); sysout(sys)"; |
|
|
442 run_cmd |
|
|
443 |
|
|
444 printf("Other syssetsignals demos are in the Block diagram demo program bddemo\n"); |
|
|
445 elseif(formopt == 5) |
|
|
446 help sysgettsam |
|
|
447 elseif(formopt == 6) |
|
|
448 help sysdimensions |
|
|
449 elseif(formopt == 7) |
|
|
450 help sysgettype |
|
3213
|
451 endif |
|
|
452 prompt |
|
|
453 endwhile |
|
|
454 elseif(syschoice== ch_update) |
|
|
455 disp("The OCST system data structure format will store a system in the same format") |
|
|
456 disp("as that with which it was initialized. For example, consider the following:") |
|
3386
|
457 cmd = "sys=zp2sys([1, 2],[3, 4, 5],6)"; |
|
3213
|
458 run_cmd |
|
|
459 disp(" ") |
|
|
460 disp("Notice the internal variables in the structure include zer, pol, and k,") |
|
|
461 disp("the required variables for zero-pole form. We can update the system") |
|
|
462 disp("to include state-space form as follows:") |
|
|
463 cmd = "sys = sysupdate(sys,\"ss\")"; |
|
|
464 run_cmd |
|
|
465 disp(" ") |
|
|
466 disp("Now the sys data structure includes variables a, b, c, and d, as well") |
|
|
467 disp("the default state names stname. sysupdate is usually used internally in") |
|
|
468 disp("the OCST, but can be used manually if desired. A full description of") |
|
|
469 disp("sysupdate is as follows:") |
|
|
470 help sysupdate |
|
|
471 prompt |
|
|
472 elseif(syschoice == ch_view) |
|
|
473 disp("The sysout command can be used to view a system in any desired format.") |
|
|
474 disp("For example, consider the system created as follows:") |
|
3386
|
475 cmd = "aircraft=zp2sys(1,[0, 0],1,0,\"aileron angle\",\"theta\");"; run_cmd |
|
3213
|
476 disp("The system may be viewed in its default format (zero-pole) as follows") |
|
|
477 cmd = "sysout(aircraft)"; |
|
|
478 run_cmd |
|
|
479 disp(" ") |
|
|
480 disp("The system may be viewed in state-space or transfer function form as well:") |
|
|
481 cmd = "sysout(aircraft,\"ss\")"; |
|
|
482 run_cmd |
|
|
483 cmd = "sysout(aircraft,\"tf\")"; |
|
|
484 run_cmd |
|
|
485 disp("A complete description of sysout is below:") |
|
|
486 help sysout |
|
|
487 prompt |
|
|
488 elseif(syschoice == ch_details) |
|
|
489 packedform |
|
|
490 endif |
|
|
491 |
|
|
492 endwhile |
|
|
493 page_screen_output = save_val; |
|
|
494 endfunction |
|
|
495 |
