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