home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / octa21fb.zip / octave / SCRIPTS.ZIP / scripts.fat / control / bddemo.m < prev    next >
Text File  |  1999-12-24  |  24KB  |  612 lines
  1. ## Copyright (C) 1996 Auburn University.  All Rights Reserved
  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. 
  18.  
  19. ## -*- texinfo -*-
  20. ## @deftypefn {Function File } { outputs =} bddemo ( inputs ) 
  21. ##  Octave Controls toolbox demo: Block Diagram Manipulations demo
  22. ## @end deftypefn
  23.  
  24. function bddemo ()
  25.  
  26.   ## Written by David Clem August 15, 1994
  27.   ## Modified by A S Hodel Summer-Fall 1996
  28.  
  29.   sav_page = page_screen_output;
  30.   page_screen_output = 1;
  31.  
  32.   while (1)
  33.     clc
  34.     k=0;
  35.     while(k > 14 || k < 1)
  36.       k = menu("Octave Block Diagram Manipulations Demo", ...
  37.       "sysadd/syssub: F(s) = G(s) +/- H(s)", ...
  38.      "sysapp: add new inputs/outputs", ...
  39.     "syssetsg: change names of inputs, outputs, and/or states", ...
  40.     "syscnct: connect specified system inputs/outputs", ...
  41.     "syscont/sysdisc: extract the continuous (discrete) part of a system", ...
  42.     "sysdup: duplicate specified inputs/outputs", ...
  43.     "sysgroup: group two systems into a single system,", ...
  44.     "sysmult: F(s) = G(s)*H(s) (series connection)", ...
  45.     "sysprune: keep only specified inputs/outputs", ...
  46.     "sysscale: scale inputs/outputs by specified gain matrices", ...
  47.     "parallel: parallel connection of two systems", ...
  48.     "buildssc: the combination of all", ...
  49.     "Design examples:", ...
  50.     "Return to main demo menu");
  51.     endwhile
  52.     if (k == 1)
  53.       clc
  54.       disp("sysadd: add two systems together")
  55.       disp("syssub: subtract F = G - H")
  56.       prompt
  57.       help sysadd
  58.       prompt
  59.       help syssub
  60.       prompt
  61.       disp('Example #1, \n')
  62.       cmd = "sys1 = tf2sys([1 -1],[1 2 1]);";
  63.       run_cmd
  64.       cmd = "sys2 = tf2sys([1 -1],[1 2 3]);";
  65.       run_cmd
  66.       disp("sys1=")
  67.       sysout(sys1);
  68.       prompt
  69.       disp("sys2=")
  70.       sysout(sys2);
  71.       cmd = "sys_sum1 = sysadd(sys1,sys1);";
  72.       run_cmd
  73.       disp("This example adds sys1 to itself.")
  74.       cmd = "sysout(sys_sum1)";
  75.       run_cmd
  76.       disp("Notice that the numerator is twice what it used to be.")
  77.       prompt
  78.       disp("Example 2:")
  79.       cmd = "sys_sub1 = syssub(sys1,sys2);";
  80.       run_cmd
  81.       disp("Notice that sysadd (actually sysgroup, called by sysadd) lets you")
  82.       disp("know that your two systems had identical names for their states,")
  83.       disp("inputs and outputs.  The warning message is perfectly harmless,")
  84.       disp("and is provided for user information only.")
  85.       disp("sys_sub1=")
  86.       sysout(sys_sub1)
  87.       disp("Notice that, since the two transfer functions had different")
  88.       disp("denominators, syssub converted the primary system type to ")
  89.       disp("state space.  This is the typical behavior unless the")
  90.       disp("the two systems are both SISO, they both have the same poles,")
  91.       disp("and at least one of them has  tf for its primary system type.");
  92.       prompt
  93.     elseif (k == 2)
  94.       disp("sysapp: add new inputs and/or outputs to a system")
  95.       help sysapp
  96.       prompt
  97.       disp("Consider a double-integrator system:")
  98.       sys = tf2sys(1, [1, 0, 0]);
  99.       sys=sysupdat(sys,"ss");
  100.       sysout(sys,"ss");
  101.       disp("We add a velocity disturbance input as follows:")
  102.       cmd = "sys1=sysapp(sys,[1;0]);";
  103.       run_cmd
  104.       sysout(sys1,"ss");
  105.       disp("Names of inputs can be included as follows:")
  106.       cmd = "sys1=sysapp(sys,[1;0], [],[],[],\"Disturb\");";
  107.       run_cmd
  108.       disp("Notice that empty matrices can be listed for the D matrix if")
  109.       disp("all entries are zeros.")
  110.       disp(" ")
  111.       disp("sys1 is thus:")
  112.       sysout(sys1);
  113.       prompt
  114.     elseif (k == 3)
  115.       disp("syssetsg:")
  116.       help syssetsg
  117.       disp("Example system");
  118.       a = rand(3,3);
  119.       b = rand(3,2);
  120.       c = rand(2,3);
  121.       sys = ss2sys(a,b,c);
  122.       sysout(sys);
  123.       prompt
  124.       disp("Change state names to larry, moe, and curly as follows:")
  125.       cmd = "sys = syssetsg(sys,\"st\",list(\"larry\",\"moe  \" , \"curly\"));";
  126.       run_cmd
  127.       disp("Indicate that output 2 is discrete-time:")
  128.       cmd = "sys = syssetsg(sys,\"yd\",1,2);";
  129.       run_cmd
  130.       disp("Change output 2 name to \"Vir\"");
  131.       cmd = "sys = syssetsg(sys,\"out\",\"Vir\",2);";
  132.       run_cmd
  133.       disp("Resulting system is:")
  134.       sysout(sys);
  135.       prompt
  136.     elseif (k == 4)
  137.       help syscnct
  138.       prompt
  139.       disp("********* N O T E *********")
  140.       disp("syscnct is demonstrated fully in the design examples (option 13)");
  141.       prompt
  142.     elseif (k == 5)
  143.       disp("syscont and sysdisc: ")
  144.       disp("Example block diagram 1:")
  145.       disp("        ------------------     ---------------------");
  146.       disp(" u_in ->| Discrete system |--->| Continuous system | ---> y_out");
  147.       disp("        ------------------     ---------------------");
  148.       sys1 = tf2sys([1, 2],[1, 2, 1], 1,"u_in","y_disc");
  149.       sys2 = tf2sys([1, 0],[1, -3, -2],0,"c_in","y_out");
  150.       sys = sysmult(sys2,sys1);
  151.       disp("Consider the hybrid system")
  152.       sysout(sys);
  153.       prompt
  154.       help syscont
  155.       disp("The continuous part of the system can be extracted with syscont")
  156.       cmd = "[csys,Acd,Ccd] = syscont(sys);";
  157.       run_cmd
  158.       disp("The resulting csys is")
  159.       sysout(csys);
  160.       disp("Notice that B is 0; there is no purely continuous path from the")
  161.       disp("input to the output");
  162.       prompt
  163.       help sysdisc
  164.       disp("The discrete part of the system can be extracted with sysdisc")
  165.       cmd = "[dsys,Adc,Cdc] = sysdisc(sys)";
  166.       run_cmd
  167.       disp("The resulting dsys is")
  168.       sysout(dsys);
  169.       disp("sysdisc returns dsys=empty since sys has no discrete outputs.");
  170.       prompt
  171.       disp("Example block diagram 2:")
  172.       sys1 = tf2sys([1, 2],[1, 2, 1], 1,"u_in","y_disc");
  173.       sys2 = tf2sys([1, 0],[1, -3, -2],0,"c_in","y_out");
  174.       disp("             ---------------------")
  175.       disp(" u_in -->o-->| Discrete system   | --------> y_disc")
  176.       disp("         ^   ---------------------    |")  
  177.       disp("         |                            | ");
  178.       disp("         -----------------------------|---")
  179.       disp("                                      |  |")
  180.       disp("         ------------------------------  |")
  181.       disp("         |                               |")
  182.       disp("         v   ---------------------       |")
  183.       disp(" c_in -->o-->| continuous system | --------> y_out")
  184.       disp("             ---------------------")
  185.       disp("repeat the above example with sys=")
  186.       sys = sysgroup(sys1, sys2);
  187.       sysout(sys)
  188.       prompt
  189.       sys = syscnct(sys,[1, 2],[2, 1]);
  190.       sysout(sys);
  191.       cmd = "[csys,Acd,Bcd] = syscont(sys);";
  192.       run_cmd
  193.       cmd = "[dsys,Acd,Bcd] = sysdisc(sys);";
  194.       run_cmd
  195.       disp("csys is now")
  196.       sysout(csys)
  197.       disp("dsys is now")
  198.       sysout(dsys);
  199.       prompt
  200.     elseif (k == 6)
  201.       help sysdup
  202.       prompt
  203.       disp("********* N O T E *********")
  204.       disp("sysdup is fully demonstrated in the design examples (option 13)")
  205.       prompt
  206.     elseif (k == 7)
  207.       help sysgroup
  208.       disp(" ")
  209.       prompt
  210.       disp("Example: combine two SISO systems together:")
  211.       cmd = "sys_a=tf2sys([1, 2],[3, 4]);";
  212.       run_cmd
  213.       cmd = "sys_b=tf2sys([5, 6],[7, 8],1);";
  214.       run_cmd
  215.       cmd = "sys_g=sysgroup(sys_a,sys_b);";
  216.       run_cmd
  217.       disp("Notice that sysgroup warns you when you join a purely continuous")
  218.       disp("system to a purely discrete system.  sysgroup also warns when")
  219.       disp("you join two systems that have common state, input, or output names.")
  220.       cmd = "sysout(sys_g)";
  221.       run_cmd
  222.       disp("Since the grouped system is a multiple-input multiple-output system,")
  223.       disp("the output system is by default in state-space format.")
  224.       disp(" ")
  225.       disp("********* N O T E *********")
  226.       disp("sysgroup is further demonstrated in the design examples (option 13)")
  227.       prompt
  228.     elseif (k == 8)
  229.       help sysmult
  230.       disp("sysmult performs a series connection of two systems.")
  231.       disp("Example 1")
  232.       disp(" ")
  233.       disp("         ----------     ----------")
  234.       disp("   u --->|  Bsys  |---->|  Asys  |---> y")
  235.       disp("         ----------     ----------")
  236.       disp(" ")
  237.       Asys = tf2sys(1,[1, 2, 1],0,"a_in","a_out");
  238.       Bsys = tf2sys([2, 3],[1, 3, 2],0,"b_in","b_out");
  239.       disp("Asys=")
  240.       sysout(Asys);
  241.       disp("Bsys=");
  242.       sysout(Bsys);
  243.       cmd = "sys = sysmult(Asys,Bsys);";
  244.       run_cmd
  245.       disp("sys =")
  246.       sysout(sys);
  247.       disp("Notice that sysmult automatically transforms to state space")
  248.       disp("internal representation.  This is to avoid numerical problems")
  249.       disp("when multiplying polynoms");
  250.       prompt
  251.       disp("Example 2: same system, except that Bsys is discrete-time");
  252.       Bsys = tf2sys([2, 3],[1, 3, 2],1e-2,"b_in","b_out");
  253.       sysout(Bsys);
  254.       cmd = "sys = sysmult(Asys,Bsys);";
  255.       run_cmd
  256.       disp("sys =")
  257.       sysout(sys);
  258.       prompt
  259.     elseif (k == 9)
  260.       help sysprune
  261.       prompt
  262.       disp("********* N O T E *********")
  263.       disp("sysprune is demonstrated in the design examples (option 13)");
  264.       prompt
  265.     elseif (k == 10)
  266.       help sysscale
  267.       disp(" ")
  268.       prompt
  269.       disp("********* N O T E *********")
  270.       disp("See the design examples (option 13) for use of sysscale.")
  271.       prompt
  272.     elseif ( k == 11)
  273.       help parallel
  274.       disp("parallel operates by making a call to sysgroup and sysscale.")
  275.       disp("Example:")
  276.       sys1 = tf2sys(1,[1, 1],0,"in1","out1");
  277.       sys2 = tf2sys(2,[1, 2],0,"in2","out2");
  278.       disp("sys1=")
  279.       sysout(sys1);
  280.       disp("sys2=")
  281.       sysout(sys2);
  282.       cmd = "sysp = parallel(sys1,sys2);";
  283.       run_cmd
  284.       disp("sysp=")
  285.       sysout(sysp);
  286.       prompt
  287.       disp("parallel can be used for multiple input systems as well:")
  288.  
  289.       in1 = list("u1.1","u1.2");
  290.       in2 = list("u2.1","u2.2");
  291.       out1 = list("y1.1","y1.2");
  292.       out2 = list("y2.1","y2.2");
  293.  
  294.       sys1 = ss2sys([-1, 0; 0, -2],eye(2),eye(2),[]);
  295.       sys2 = ss2sys([-2, 0; 0, -4],eye(2),eye(2),[]);
  296.  
  297.       sys1 = syssetsg(sys1,"in",in1);
  298.       sys1 = syssetsg(sys1,"out",out1);
  299.  
  300.       sys2 = syssetsg(sys2,"in",in2);
  301.       sys2 = syssetsg(sys2,"out",out2);
  302.      
  303.       disp("sys1=")
  304.       sysout(sys1);
  305.       disp("sys2=")
  306.       sysout(sys2);
  307.       cmd = "sysp = parallel(sys1,sys2);";
  308.       run_cmd
  309.       disp("sysp=")
  310.       sysout(sysp);
  311.       prompt
  312.     elseif (k == 12)
  313.       ## buildssc description
  314.       disp(" ")
  315.       disp("        ---------------------------------------")
  316.       disp("                    b u i l d s s i c")
  317.       disp("          (BUILD State Space InterConnections)")
  318.       disp("        ---------------------------------------")
  319.       disp(" ")
  320.       disp("buildssc builds a single system from up to 8 systems.")
  321.       disp("It's primary pupose is the forming of interconnections")
  322.       disp("for H2/H_inf designs and the building of closed loop")
  323.       disp("systems.")
  324.       disp("The interconnections may be of arbitrary complexity.")
  325.       disp("The use of buildssc is an alternative to sysgroup,")
  326.       disp("sysadd/syssub, sysapp, syscnct, sysdup, sysmult")
  327.       disp("sysprune, sysscale, parallel etc.")
  328.       disp("In contrast to these functions buildssc does not")
  329.       disp("handle mixed continuous and discrete systems. However,")
  330.       disp("discrete systems can be connected as long as their")
  331.       disp("sampling times are identical. Another drawback: the")
  332.       disp("names of input/output and state variables are clobbered.")
  333.       disp("Of course, buildsysic is useful in combination with sysgroup,")
  334.       disp("sysmult etc.")
  335.       prompt
  336.       disp("********* N O T E *********")
  337.       disp("buildssc is demonstrated in the design examples (option 13)");
  338.       prompt
  339.     elseif (k == 13)
  340.       disp("Design examples")
  341.       disp("Packed system matrices may be connected and manipulated")
  342.       disp("With the functions listed below:")
  343.       disp("  sysdup: duplicate selected inputs/outputs")
  344.       disp("  syscnct: connect selected inputs/outputs")
  345.       disp("  sysgroup: group two systems together")
  346.       disp("  sysprune: prune a system to keep only selected inputs and outputs")
  347.       disp("  sysscale:pre/post multiply a system by constant matrices")
  348.       disp("  buildssc: connect systems with arbitrary complexity.")
  349.       prompt
  350.       disp("As a simple example, we will construct the system block ")
  351.       disp("diagram shown below ")
  352.       disp(" ")
  353.       disp("         +          --------    --------");
  354.       disp("  r(t) ---> (+) --->| K(s) |--->| P(s) | ----> y(t)");
  355.       disp("            -^      --------    --------  |");
  356.       disp("             |                            |");
  357.       disp("             ------------------------------");
  358.       disp(" ")
  359.       disp("where P(s) is the plant, K(s) is the controller.")
  360.       prompt
  361.       disp("Simple example: P(s) is a first order lag, K(s) is a PI ")
  362.       disp("controller")
  363.       nump = 1;
  364.       denp = [1, 1];
  365.       disp("P(s)=")
  366.       tfout(nump,denp)
  367.       numk = [1, 1];
  368.       denk = [1, 0];
  369.       disp("\nK(s)=")
  370.       tfout(numk,denk);
  371.       prompt
  372.       disp("We'll show three approaches.  ")
  373.       P = tf2sys(nump,denp,0,"plant input","plant output");
  374.       K = tf2sys(numk, denk,0,"controller input","controller output");
  375.  
  376.       meth = 0;
  377.       while(meth != 5)
  378.         disp("The first method consists of the following steps:")
  379.         disp("   step 1: create systems P and K")
  380.         disp("   step 2: group P and K together")
  381.         disp("   step 3: create a summing junction")
  382.         disp("   step 4: connect outputs to respective inputs")
  383.         disp("   step 5: prune the desired i/o connections")
  384.         disp("The second method is done as follows:")
  385.         disp("   step 1: create systems P and K and a summing block S")
  386.         disp("   step 2: connect P, K, and S in series")
  387.         disp("   step 3: connect y to inverted summing connection")
  388.         disp("   step 4: prune the desired i/o connections")
  389.         disp("The third method uses buildssc:")
  390.         disp("   step 1: GW = buildssc(...,K,P)")
  391.         disp(" ")
  392.         disp("Other design examples are in dgkfdemo (cntrldm option 7)")
  393.         disp(" ")
  394.         meth = menu("Select design example method", ...
  395.         "Method 1 ", ...
  396.         "Method 1 (w/o algebraic loop warning)", ...
  397.         "Method 2", ...
  398.         "Method 3", ...
  399.         "Exit design examples");
  400.         if(meth == 1)
  401.           disp(" * * * Method 1 * * *")
  402.           disp(" ")
  403.           disp("         +          --------    --------");
  404.           disp("  r(t) ---> (+) --->| K(s) |--->| P(s) | ----> y(t)");
  405.           disp("            -^      --------    --------  |");
  406.           disp("             |                            |");
  407.           disp("             ------------------------------");
  408.           disp(" ")
  409.           disp("Step 1: put plants in system format:");
  410.           nump
  411.           denp
  412.           cmd =  "P = tf2sys(nump,denp,0,""plant input"",""plant output"");";
  413.           run_cmd
  414.           disp("P=")
  415.           sysout(P)
  416.           prompt
  417.           numk
  418.           denk
  419.           cmd = "K = tf2sys(numk, denk,0,""controller input"",""controller output"");";
  420.           run_cmd
  421.           sysout(K)
  422.           prompt
  423.           disp("Step 2: group the systems together")
  424.           cmd = "PK = sysgroup(P,K);";
  425.           run_cmd
  426.           disp("PK=")
  427.           sysout(PK);
  428.           prompt
  429.           disp(" ")
  430.           disp("                           y2   u1")
  431.           disp("         +          --------    --------");
  432.           disp("  r(t) ---> (+) --->| K(s) |--->| P(s) | ----> y(t)");
  433.           disp("  u2        -^      --------    --------    |  y1");
  434.           disp("          u3 |                              |");
  435.           disp("             --------------------------------");
  436.           disp(" ")
  437.           disp("The controller has two inputs summed together, r(t)")
  438.           disp("and the negative feedback of  y(t)")
  439.           disp("Step 3a: duplicate controller input: (input 2 of PK)")
  440.           prompt
  441.           cmd = "PK = sysdup(PK,[],2);";
  442.           run_cmd
  443.           disp("PK=")
  444.           sysout(PK);
  445.           disp("Notice that PK now has three inputs (input 3 is a duplicate ");
  446.           prompt("of input 2).  Press return to go on")
  447.           disp("Step 3b: scale input 3 by -1")
  448.           cmd = "PK = sysscale(PK,[],diag([1, 1, -1]));";
  449.           run_cmd
  450.           disp("PK=")
  451.           sysout(PK);
  452.           prompt
  453.           disp("Step 4: connect:")
  454.           disp("   y(t) (output 1) to the negative sum junction (input 3)")
  455.           disp("   u(t) (output 2) to plant input (input 1)")
  456.           disp("and prune extraneous inputs/outputs (retain input 2, output 1)")
  457.           prompt
  458.           out_connect = [1, 2]
  459.           in_connect = [3, 1]
  460.           cmd = "PK0 = syscnct(PK,out_connect,in_connect);"; 
  461.           run_cmd
  462.           prompt
  463.           disp("Notice that syscnct detects the possibility of algebraic") 
  464.           disp("connections when connecting inputs.  Option 2 (Method 1 ")
  465.           disp("without algebraic loops) shows how to avoid this warning")
  466.           disp("by performing connections one at a time.")
  467.           prompt
  468.           disp("PK0=")
  469.           sysout(PK0);
  470.           disp("Notice that the connected inputs now have stars on their")
  471.           disp("names.  This is how the Octave controls toolbox reminds you")
  472.           disp("that the loop has been closed around these inputs.")
  473.           prompt("Press return to prune extra inputs/outputs from system")
  474.           disp("Only keep plant output (output 1) and r(t) (input 2)")
  475.           cmd = "PK0 = sysprune(PK0,1,2);";
  476.           run_cmd
  477.           disp("PK0=")
  478.           sysout(PK0);
  479.           prompt
  480.           disp("The resulting closed-loop transfer function is obtained as follows:")
  481.           cmd = "[num,den] = sys2tf(PK0);";
  482.           run_cmd
  483.           prompt
  484.           disp("Transfer function is now")
  485.           tfout(num,den)
  486.           disp("You can check this: Pk0=PK/(1+PK), as expected")
  487.           prompt
  488.         elseif(meth == 2)
  489.           disp("Method 1 without algebraic loops")
  490.           disp(" ")
  491.           disp("                           y2   u1")
  492.           disp("         +          --------    --------");
  493.           disp("  r(t) ---> (+) --->| K(s) |--->| P(s) | ----> y(t)");
  494.           disp("  u2        -^      --------    --------    |  y1");
  495.           disp("          u3 |                              |");
  496.           disp("             --------------------------------");
  497.           disp(" ")
  498.           disp("Recall that syscnct checks for algebraic loops.  Although")
  499.           disp("Design option 1 gets a warning message about a possible");
  500.        disp("algebraic loop, such a loop does not exist.")
  501.           disp("This can be seen by performing the connections one at a time");
  502.           cmd = "PK = sysgroup(P,K);";
  503.           run_cmd
  504.           disp("PK=")
  505.           sysout(PK);
  506.           disp("Create an additial inverted input to the controller.")
  507.           cmd = "PK = sysdup(PK,[],2);";
  508.           run_cmd
  509.           cmd = "PK = sysscale(PK,[],diag([1,1,-1]));";
  510.           run_cmd
  511.           disp("PK=")
  512.           sysout(PK);
  513.           disp("Connect controller to plant:")
  514.           cmd = "PK0 = syscnct(PK,2,1);"; 
  515.           run_cmd
  516.           disp("Plant output to negative control input")
  517.           cmd = "PK0 = syscnct(PK0,1,3);"; 
  518.           run_cmd
  519.           disp("Only keep plant output (output 1) and r(t) (input 2)")
  520.           cmd = "PK0 = sysprune(PK0,1,2);";
  521.           run_cmd
  522.           disp("PK0=")
  523.           sysout(PK0);
  524.           prompt
  525.           disp("The transfer function form of PK0 is:")
  526.           sysout(PK0,"tf");
  527.           prompt
  528.         elseif(meth == 3)
  529.           disp(" * * * Method 2 * * *")
  530.           disp(" ")
  531.           disp("         +          --------    --------");
  532.           disp("  r(t) ---> (+) --->| K(s) |--->| P(s) | ----> y(t)");
  533.           disp("            -^      --------    --------  |");
  534.           disp("             |                            |");
  535.           disp("             ------------------------------");
  536.           disp(" ")
  537.       disp("Step 1: We've already created systems P and K.  Create a sum ")
  538.       disp("block as follows:")
  539.       cmd = "S = ss2sys([],[],[],[1, -1],0,0,0,[],list(""r(t)"",""y(t)""),""e(t)"");";
  540.       run_cmd
  541.       disp("(You may wish to look at help ss2sys to see what the above does)");
  542.       disp("S=")
  543.       sysout(S)
  544.       disp("notice that this is just a gain block that outputs e = r - y")
  545.       prompt
  546.       disp("Step 2: series connections of P, K, and S")
  547.       cmd = "PKS = sysmult(P,sysmult(K,S));";
  548.       run_cmd
  549.       disp("PKS=")
  550.       sysout(PKS)
  551.       disp("Step 3: connect y to inverted input")
  552.       cmd = "PKcl = syscnct(PKS,1,2);";
  553.       run_cmd
  554.       disp("PKcl=")
  555.       sysout(PKcl)
  556.       disp("Step 4: prune desired inputs/outputs")
  557.       cmd = "PKcl=sysprune(PKcl,1,1);";
  558.       run_cmd
  559.       disp("PKcl=")
  560.       sysout(PKcl)
  561.       prompt
  562.         elseif(meth == 4)
  563.           disp(" * * * Method 3 * * *")
  564.           disp(" ")
  565.           disp("         +          --------    --------");
  566.           disp("  r(t) ---> (+) --->| K(s) |--->| P(s) | ----> y(t)");
  567.           disp("            -^      --------    --------  |");
  568.           disp("             |                            |");
  569.           disp("             ------------------------------");
  570.           disp(" ")
  571.       disp("Step 1: We've already created systems P and K.")
  572.       disp("        Let us call buildssc:")
  573.       disp("   PKcl = buildssc([1, 2; 2, -1],[],[1],[2],P,K)")
  574.       disp(" ")
  575.       disp("                         ^      ^  ^   ^  ^ ^")
  576.       disp("                         |      |  |   |  | |")
  577.       disp("     Connection list ----+      |  |   |  | |")
  578.       disp(" internal input list -----------+  |   |  | +-- controller")
  579.       disp("         output list --------------+   |  |")
  580.       disp("          input list ------------------+  +---- plant")
  581.       disp(" ")
  582.       disp(" Connection list: connect input 1 (P) with output 2 (K)")
  583.       disp("                  connect input 2 (K) with neg. outp. 1 (P)")
  584.       disp(" ")
  585.       disp("  int. inp. list: do not append internal inputs")
  586.       disp("                  (e.g. the internal input of K (r-y))")
  587.       disp(" ")
  588.       disp("     output list: the only output is 1 (P), positive")
  589.       disp(" ")
  590.       disp("      input list: the only input is 2 (K), positive")
  591.       disp(" ")
  592.       cmd = "PKcl = buildssc([1, 2; 2, -1],[],[1],[2],P,K);"
  593.       run_cmd
  594.       sysout(PKcl)
  595.       prompt
  596.       disp("The transfer function form of PKcl is:")
  597.       sysout(PKcl,"tf");
  598.       disp("You can check this: PKcl = PK / (1 + PK), as expected")
  599.       prompt
  600.       elseif(meth != 5)
  601.         disp("Illegal selection")
  602.      endif
  603.     endwhile
  604.       
  605.     elseif (k == 14)
  606.       return
  607.     endif
  608.   endwhile  
  609.   implict_str_to_num_ok = str_sav;
  610.   page_screen_output = sav_page;
  611. endfunction
  612.