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