home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / octa21fb.zip / octave / SCRIPTS.ZIP / scripts / control / frdemo.m < prev    next >
Encoding:
Text File  |  1999-12-15  |  23.8 KB  |  601 lines
  1. ## Copyright (C) 1996,1998 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 } { } frdemo ( ) 
  21. ## Octave Controls toolbox demo: Frequency Response demo
  22. ## @end deftypefn
  23.  
  24. function frdemo ()
  25.  
  26.   ## Written by David Clem August 15, 1994 
  27.  
  28.   ## a s hodel: updated to match new order of ss2zp outputs
  29.   ## J Ingram:  updated for system data structure format August 1996
  30.  
  31.   disp("")
  32.   clc
  33.   j = 0;
  34.   while (j != 4)
  35.     disp("");
  36.     j = menu("Octave Controls Systems Toolbox Frequency Response Demo",...
  37.              'Bode analysis (bode)',...
  38.              'Nyquist analysis (nyquist)',...
  39.          "Nichols analysis (nichols)", ...
  40.              'Return to main demo menu');
  41.    
  42.     if (j == 1)
  43.       k1 = 0;
  44.       while (k1 != 4)
  45.         disp("\n");
  46.         clc
  47.  
  48.         k1 = menu("Bode analysis (bode)",...
  49.                   'Continuous system bode analysis',...
  50.                   'Discrete system bode analysis',...
  51.                   'Bode command description', ...
  52.                   'Return to frdemo menu');
  53.        
  54.         if( k1 == 1 )
  55.           disp(" ")
  56.           clc  
  57.           disp("\nContinuous system bode analysis\n");
  58.           disp("Example #1:")
  59.           disp("\nConsider the system sys1=");
  60.           sys1=tf2sys([1, 1], [1, 0, -1]);
  61.           sysout(sys1);
  62.           disp("\nPole-zero form can be obtained as follows:")
  63.           cmd = "sysout(sys1,""zp"");";
  64.           run_cmd;
  65.           disp("The systems bode plot is obtained as follows:");
  66.           cmd = "bode(sys1);";
  67.           run_cmd;  
  68.           disp("\nNotice that bode automatically labels the plots according to")
  69.           disp("the selected input/output combinations.")
  70.           disp(" ")
  71.           disp("If the frequency range is not specified, bode automatically")
  72.           disp("selects a frequency range based on the natural frequencies of")
  73.           disp("of all poles away from s=0 (or z=1 in discrete time).  Bode")
  74.           disp("then checks to make sure that the phase plot is sufficiently")
  75.           disp("smooth that relevant plot behavior is captured.")
  76.           disp("")
  77.           disp("Bode exits with an error if the system is mixed (both continuous")
  78.           disp("and discrete; see is_digital for conditions)")
  79.           prompt
  80.           disp("\nIf the plot magnitude, phase and frequency data is desired, the");
  81.           disp("user can enter the following command:");
  82.           disp("\n[Mag,Phase,w] = bode(sys);");
  83.           disp("\nThis will return three vectors containing the magnitude,");
  84.           disp("phase and frequency.\n");
  85.           prompt;
  86.  
  87.           disp("")
  88.           clc
  89.           disp("Example #2, sys2=")
  90.           cmd = "sys2=zp2sys(1, [-1, -5], 10);";
  91.           eval(cmd);
  92.           cmd = "sysout(sys2);";
  93.           eval(cmd);
  94.           disp("\nThe bode plot command is identical to the tf form:")
  95.           cmd = "bode(sys2);";
  96.           run_cmd;  
  97.           disp("\nThe internal representation of the system is not important;")
  98.           disp("bode automatically sorts it out internally.")
  99.           prompt;
  100.  
  101.           disp("")
  102.           clc
  103.           disp("Example #3, Consider the following state space system sys3=:\n");
  104.           cmd = "sys3=ss2sys([0, 1; -1000, -1001], [0; 1], [0, -891], 1);";
  105.           eval(cmd);
  106.           cmd = "sysout(sys3);";
  107.           eval(cmd);
  108.           disp("\nOnce again, the bode plot command is the same:");
  109.           cmd = "bode(sys3);";
  110.           run_cmd;
  111.           disp("\nSuppose the user is interested in the response of the system");
  112.           disp("defined over the input frequency range of 1 - 1000 rad/s.\n");
  113.           disp("First, a frequency vector is required.  It can be created");
  114.           disp("with the command:\n");
  115.           cmd = "wrange = logspace(log10(1),log10(1000),100);";
  116.           disp(cmd); 
  117.           eval(cmd);
  118.           disp("\nThis creates a logarithmically scaled frequency vector with");
  119.           disp("100 values between 1 and 1000 rad/s\n");
  120.           disp("Then, the bode command includes wrange in the input arguments");
  121.           disp("like this:");
  122.           cmd = "bode(sys3,wrange);";
  123.           run_cmd;
  124.           prompt; 
  125.  
  126.           disp("")
  127.           clc
  128.             disp("\nExample #4, The state-space system from example 3 will be");
  129.           disp("grouped with the system from example 2 to form a MIMO system");
  130.           disp("The commands to do this grouping are as follows (changing signal");
  131.           disp("names for clarity):");
  132.           cmd = "sys2 = syssetsignals(sys2,\"out\",\"y_sys2\");";
  133.           disp(cmd);  eval(cmd);
  134.           cmd = "sys2 = syssetsignals(sys2,\"in\",\"u_sys2\");";
  135.           disp(cmd);  eval(cmd);
  136.           cmd = "nn = sysdimensions(sys2);";
  137.           disp(cmd);  eval(cmd);
  138.           cmd = "[nn,nz] = sysdimensions(sys2);";
  139.           disp(cmd);  eval(cmd);
  140.           cmd = "sys2 = syssetsignals(sys2,\"st\",sysdefioname(nn+nz,\"x_sys2\"));";
  141.           disp(cmd);  eval(cmd);
  142.           cmd = "sys_mimo = sysgroup(sys2,sys3);";
  143.           disp(cmd); eval(cmd);
  144.           disp("The resulting state-space system (after changing signal names");
  145.           disp("in sys2) is");
  146.           cmd = "sysout(sys_mimo)";
  147.           eval(cmd);
  148.           disp("\nNotice that there are now 2 inputs and 2 outputs, and that it did");
  149.        disp("not matter what form the two systems were in when they were grouped.");
  150.           disp(["\nTo view the system\'s bode plots, execute the",...
  151.             " following command:\n"])
  152.           cmd = "bode(sys_mimo);";
  153.           run_cmd;
  154.           prompt
  155.           disp("\nTo view the bode plots for selected  channels, the command form changes:")
  156.           cmd = "wrange = [];";
  157.           disp(cmd)
  158.           eval(cmd);
  159.           cmd = "out = 1;";
  160.           disp(cmd)
  161.           eval(cmd);
  162.           cmd = "in = 1;";
  163.           disp(cmd)
  164.           eval(cmd);
  165.           cmd = "bode(sys_mimo,wrange,out,in);";
  166.           run_cmd;
  167.           disp("\nNotice that this bode plot is the same as the plot from example 2.");         
  168.           prompt
  169.           closeplot
  170.  
  171.         elseif( k1 == 2 )
  172.           disp("")
  173.           clc
  174.           disp("\nDiscrete system bode analysis\n");
  175.           disp("Display bode plots of a discrete SISO system (dbode)\n")
  176.             disp("Example #1, Consider the following discrete transfer");
  177.           disp(" function:\n");
  178.           cmd = "sys1 = tf2sys([0.00100502, -0.00099502], [1, -2, 1], 0.001);";
  179.           disp(cmd);
  180.           eval(cmd);
  181.        cmd = "sysout(sys1)";
  182.           disp(cmd);
  183.           eval(cmd);
  184.             disp("\nTo examine open loop zeros and poles of the system,");
  185.           disp("use the command:\n")
  186.           cmd = "sysout(sys1,""zp"");";
  187.           run_cmd;      
  188.              disp("\nTo view the system's bode plots, execute the following");
  189.           disp("command:\n")
  190.             cmd = "bode(sys1);";
  191.           run_cmd;
  192.           disp("\nNotice (1) the plot label uses exp(jwT) for its title axis. This")
  193.           disp("           allows the user to determine what kind of system was")
  194.           disp("           used to generate the bode plot");
  195.           disp("       (2) the system poles are both at z=1, (break frequency at")
  196.           disp("           jwT = 0); pure integrator poles like this are discarded")
  197.           disp("           by Octave when computing the plot frequency range.")
  198.  
  199.           disp("\nIf magnitude, phase, and frequency data are also desired,");
  200.           disp(" perform the following command instead:\n");         
  201.           disp("[M,P,w]=dbode(num,den,T,wrange).\n Where:");
  202.           disp("M => Bode magnitude response data");
  203.           disp("P => Bode phase response data");
  204.           disp("w => frequencies that M and P were evaluated at");
  205.           disp("sys1 => system data structure")
  206.           disp("T => sample period")
  207.           disp("wrange => optional vector of frequencies")
  208.           disp("          if wrange is entered in the argument list, the");  
  209.           disp("      system will be evaluated at these specific"); 
  210.           disp("       frequencies\n"); 
  211.  
  212.           prompt
  213.           disp("")
  214.           clc    
  215.           disp("Example #2, Consider the following set of discrete poles and"); 
  216.           disp("zeros:\n")
  217.        cmd = "sys2 = zp2sys([0.99258;0.99745],[0.99961;0.99242],1,0.001);";
  218.           disp(cmd);
  219.        eval(cmd);
  220.           cmd = "sysout(sys2)";
  221.           disp(cmd);
  222.        eval(cmd);
  223.           disp("\nTo view the system's bode plots, execute the following");
  224.           disp("command:\n")
  225.             cmd = "bode(sys2);";
  226.           run_cmd;             
  227.           disp("Notice that the bode command is the same in both of the previous");
  228.           disp("examples.  The bode command is also the same for the continuous case.");
  229.           disp("The function, dbode, is no longer used.");
  230.  
  231.           prompt
  232.           disp("")
  233.           clc
  234.           disp("\nExample #3, Now consider the following state space system:\n");
  235.           cmd = "sys3 = ss2sys([.857, .0011; 0, .99930],[1;1],[-.6318, .0057096],5.2, .001);";
  236.           disp(cmd);
  237.           eval(cmd);
  238.           cmd = "sysout(sys3);";
  239.           disp(cmd);
  240.           eval(cmd);
  241.           disp("\nTo view the system's bode plots, execute the following command:\n")
  242.             cmd = "bode(sys3);";
  243.              run_cmd;
  244.           disp("\nAgain, notice that the bode command is the same regardless of the form");
  245.           disp("of the system.");
  246.           disp("\nSuppose the user is interested in the response of the system");
  247.           disp("defined over the input frequency range of 1 - 1000 rad/s.\n");
  248.           disp("First, a frequency vector is required.  It can be created");
  249.           disp("with the command:\n");
  250.           cmd = "wrange = logspace(log10(1),log10(1000),100);";
  251.           disp(cmd); 
  252.           eval(cmd);
  253.           disp("\nThis creates a logrithmetically scaled frequency vector with");
  254.           disp("100 values between 1 and 1000 rad/s\n");
  255.           disp("Then, the bode command includes wrange in the input arguments");
  256.           disp("like this:");
  257.           cmd = "bode(sys3,wrange);";
  258.           run_cmd;
  259.           prompt;      
  260.           
  261.           disp("")
  262.           clc
  263.           disp("\nExample #4, We will now examine a MIMO state-space system.  Systems");
  264.           disp("two and three will be grouped.");
  265.           cmd = "[nn,nz] = sysdimensions(sys2);";
  266.           disp(cmd); eval(cmd);
  267.           cmd = "sys2 = syssetsignals(sys2,\"out\",\"y_sys2\");";
  268.           disp(cmd); eval(cmd);
  269.           cmd = "sys2 = syssetsignals(sys2,\"in\",\"u_sys2\");";
  270.           disp(cmd); eval(cmd);
  271.           cmd = "sys2 = syssetsignals(sys2,\"st\",sysdefioname(nn+nz,\"x_sys2\"));";
  272.           disp(cmd); eval(cmd);
  273.           cmd = "sys_mimo = sysgroup(sys2,sys3);";
  274.           disp(cmd); eval(cmd);
  275.           cmd = "sysout(sys_mimo);";
  276.           disp(cmd);
  277.           eval(cmd);
  278.           disp("\nTo view the system's bode plots, execute the following command:\n")
  279.             cmd = "bode(sys_mimo);";
  280.           run_cmd;
  281.           prompt
  282.  
  283.           disp("\nThe bode plot of a single channel is viewed as follows:")
  284.           cmd = "wrange = [];";
  285.           disp(cmd)
  286.           eval(cmd);
  287.           cmd = "out = 1;";
  288.           disp(cmd)
  289.           eval(cmd);
  290.           cmd = "in = 1;";
  291.           disp(cmd)
  292.           eval(cmd);
  293.           cmd = "bode(sys_mimo,wrange,out,in);";
  294.           run_cmd;
  295.           disp("\nNotice that this bode plot is the same as the plot from example 2.");         
  296.           prompt
  297.           closeplot
  298.  
  299.         elseif( k1 == 3 )
  300.           help bode
  301.           prompt
  302.         endif
  303.       endwhile
  304.     elseif (j == 2)
  305.       k2 = 0;
  306.       disp("");
  307.       while (k2 != 4)
  308.         disp("\n");
  309.         help nyquist
  310.         prompt;
  311.         disp("")
  312.         clc;
  313.  
  314.         k2 = menu("Nyquist analysis (Nyquist)",...
  315.                   'Continuous system nyquist analysis',...
  316.               'Discrete system nyquist analysis',...
  317.               'Mixed system nyquist analysis',...
  318.                   'Return to frdemo menu');
  319.  
  320.         if( k2 == 1 )
  321.           disp("")
  322.           clc
  323.        disp("\nContinuous system nyquist analysis\n");
  324.             disp("Display Nyquist plots of a SISO system (nyquist)\n")
  325.             disp("Example #1, Consider the following transfer function:\n")
  326.           cmd = "sys1 = tf2sys(1, [1, 0.8, 1]);";
  327.           disp(cmd);
  328.           eval(cmd);
  329.           disp("To examine the transfer function, use the command:");
  330.           cmd = "sysout(sys1);";
  331.           disp(cmd);
  332.           eval(cmd);
  333.           disp("\nTo examine the open loop zeros and poles, use the command:");
  334.           cmd = "sysout(sys1,""zp"");";
  335.           run_cmd;
  336.             disp("\nTo view the system""s nyquist plot, execute the following"); 
  337.           disp("command:\n")
  338.             cmd = "nyquist(sys1);";
  339.           run_cmd;
  340.           disp("\nIf the real and imaginary parts of the response are desired,");
  341.           disp("use the following command:");
  342.              disp("command: [R,I,w]=nyquist(sys1);\n");
  343.             disp("If the user desires to evaluate the response in a certain");
  344.           disp("frequency range, he may do so by entering the following:");
  345.           disp("command: [M,P,w]=nyquist(num,den,wrange).\n")
  346.             disp("wrange is a vector of frequencies that spans the desired");
  347.           disp("viewing range.\n");
  348.             disp("This will be illustrated in the third nyquist example.\n")  
  349.              disp("Variable Description:\n")
  350.             disp("R => real part of response")
  351.             disp("I => imaginary part of response")
  352.             disp("w => frequencies that the transfer function was evaluated at")
  353.             disp("sys1 => system data structure")
  354.              disp("wrange => optional vector of frequencies")
  355.           disp("          if wrange is entered in the argument list, the");
  356.           disp("      system will be evaluated at these specific");
  357.           disp("          frequencies\n") 
  358.           prompt 
  359.           
  360.           disp("")
  361.           clc
  362.           disp("Example #2, Consider the following set of poles and zeros:\n")
  363.           cmd = "sys2 = zp2sys([-1;-4],[-2+1.4142i;-2-1.4142i],1);";
  364.           disp(cmd);
  365.           eval(cmd);
  366.           disp("\nTo examine the poles and zeros, use the command:");
  367.           cmd = "sysout(sys2)";
  368.           disp(cmd);
  369.           eval(cmd);
  370.             disp("\nTo view the system""s nyquist plot, execute the following");
  371.           disp("command:\n")
  372.             cmd = "nyquist(sys2);";
  373.           run_cmd;
  374.           prompt
  375.  
  376.           disp("")
  377.           clc
  378.           disp("\nExample #3, Consider the following state space system:\n")
  379.           cmd = "sys3 = ss2sys([0, 1, 0, 0; 0, 0, 1, 0; 0, 0, 0, 1; 0, 0, -20, -12],[0;0;0;1],[50, 100, 0, 0],0);";
  380.           disp(cmd);
  381.           eval(cmd); 
  382.           disp("\nTo examine the state-space system, use the command:");
  383.           cmd = "sysout(sys3)";
  384.           disp(cmd);
  385.           eval(cmd);      
  386.           disp("\nTo examine the poles and zeros, use the command:");
  387.           cmd = "sysout(sys3,""zp"")";
  388.           run_cmd;
  389.             disp("\nTo view the system""s nyquist plot, execute the following");
  390.           disp("commands:\n")
  391.             cmd = "nyquist(sys3);";
  392.           run_cmd;
  393.           prompt     
  394.           
  395.           disp("Example #3 (continued), If the user wishes to evaluate the");
  396.           disp("system response over a desired frequency range, he must first");
  397.           disp("create a frequency vector.\n")
  398.             disp("For example, suppose the user is interested in the response");
  399.           disp("of the system defined above over input frequency range of");
  400.           disp("3 - 100 rad/s.\n")
  401.             disp("A frequency vector can be created using the command:\n");
  402.            cmd = "wrange = logspace(log10(3),log10(100),100);";
  403.           disp(cmd);
  404.           eval(cmd); 
  405.           disp("\nNyquist can be run again using the frequency vector as");
  406.           disp("follows:\n")
  407.              cmd = "nyquist(sys3,wrange);";
  408.           run_cmd;      
  409.           prompt
  410.  
  411.           disp("")
  412.           clc
  413.           disp("Example #4,  Nyquist can be used for MIMO systems if the system has");
  414.           disp("an equal number of inputs and outputs.  Otherwise, nyquist returns");
  415.           disp("an error.  To examine a MIMO system, systems 2 and 3 will be grouped");
  416.           cmd = "[nn,nz] = sysdimensions(sys2);";
  417.           disp(cmd); eval(cmd);
  418.           cmd = "sys2 = syssetsignals(sys2,\"out\",\"y_sys2\");";
  419.           disp(cmd); eval(cmd);
  420.           cmd = "sys2 = syssetsignals(sys2,\"in\",\"u_sys2\");";
  421.           disp(cmd); eval(cmd);
  422.           cmd = "sys2 = syssetsignals(sys2,\"st\",sysdefioname(nn+nz,\"x_sys2\"));";
  423.           disp(cmd); eval(cmd);
  424.           cmd = "sys_mimo = sysgroup(sys2,sys3);";
  425.           disp(cmd); eval(cmd);
  426.           cmd = "sysout(sys_mimo);";
  427.           disp(cmd);
  428.           eval(cmd);
  429.           disp("\nTo view the system's nyquist plot, execute the following command:\n")
  430.             cmd = "nyquist(sys_mimo);";
  431.        run_cmd;
  432.           prompt
  433.           disp("\nTo view the nyquist plots for selected  channels, the command form changes:")
  434.           cmd = "nyquist(sys_mimo,[],1,1);";
  435.           run_cmd;
  436.           disp("\nNotice that this bode plot is the same as the plot from example 2.");         
  437.           prompt
  438.           closeplot
  439.  
  440.  
  441.  
  442.         elseif( k2 == 2 )
  443.           disp("")
  444.           clc 
  445.           disp("\nDiscrete system nyquist analysis\n");
  446.             disp("Display Nyquist plots of a discrete SISO system (nyquist)\n")
  447.           disp("We will first define a sampling time, T");
  448.           cmd = "T = 0.01;";
  449.           disp(cmd); 
  450.           eval(cmd);
  451.             disp("\nExample #1, Consider the following transfer function:\n")
  452.             cmd = "sys1 = tf2sys([2, -3.4, 1.5],[1, -1.6, 0.8],T);";
  453.           disp(cmd); 
  454.           eval(cmd);
  455.           disp("To examine the transfer function, use the command:");
  456.           cmd = "sysout(sys1);";
  457.           disp(cmd);
  458.           eval(cmd);
  459.           disp("\nTo examine the open loop zeros and poles, use the command:");
  460.           cmd = "sysout(sys1,""zp"")";
  461.           disp(cmd); 
  462.           eval(cmd); 
  463.             disp("\nTo view the system""s nyquist plot, execute the following"); 
  464.           disp("command:")
  465.             cmd = "nyquist(sys1);";
  466.           run_cmd;
  467.           disp("To change the range used for the frequency, a frequency");
  468.           disp("is needed.  Suppose the user would like to examine the");
  469.           disp("nyquist plot in the frequency range of 0.01 - 31.6 rad/s.");
  470.           disp("\nThe frequency vector needed to do this is created with the");
  471.           disp("command:");
  472.           cmd = "wrange = logspace(-2,1.5,200);";
  473.           disp(cmd); 
  474.           eval(cmd);    
  475.           disp("\nNyquist can be run again with this frequency vector");         
  476.           cmd = "nyquist(sys1,wrange);";
  477.           run_cmd;
  478.             disp("\nIf the real and imaginary parts of the response are desired,");
  479.           disp("perform the following command:\n");     
  480.           disp("[R,I,w]=nyquist(sys,wrange)\n")
  481.           disp("Variable Description:\n")
  482.           disp("R => real part of response")
  483.            disp("I => imaginary part of response")
  484.             disp("w => frequencies that the transfer function was evaluated at")
  485.           disp("sys => The system data structure");
  486.             disp("wrange => optional vector of frequencies")
  487.             disp("          if wrange is entered in the argument list, the");
  488.           disp("      system will be evaluated at these specific");
  489.           prompt
  490.  
  491.           disp("")
  492.           clc
  493.           disp("\nExample #2, Consider the following set of poles and zeros:\n")
  494.              cmd = "sys2 = zp2sys([0.98025 + 0.01397i; 0.98025 - 0.01397i],[0.96079;0.99005],1,T);";
  495.           disp(cmd); 
  496.           eval(cmd);
  497.           disp("\nTo examine the open loop zeros and poles, use the command:");
  498.           cmd = "sysout(sys2)";
  499.           disp(cmd); 
  500.           eval(cmd); 
  501.             disp("\nTo view the system's nyquist plot between the frequencies");
  502.           disp("0.01 - 100 rad/s, execute the following commands:\n")
  503.             cmd = "wrange = logspace(-2,2,100);";
  504.           disp(cmd); 
  505.           eval(cmd);
  506.         cmd = "nyquist(sys2,wrange);";
  507.           run_cmd;
  508.           prompt;
  509.         
  510.           disp("")
  511.           clc
  512.           disp("\nExample #3, Consider the following discrete state space");
  513.           disp("system:\n");
  514.           disp("This example will use the same system used in the third");
  515.           disp("example in the continuous nyquist demo.  First, that system");
  516.           disp("will have to be re-entered useing the following commands:\n");
  517.           cmd = "sys3 = ss2sys([0, 1, 0, 0; 0, 0, 1, 0; 0, 0, 0, 1; 0, 0, -20, -12],[0;0;0;1],[50, 100, 0, 0],0);";
  518.           disp(cmd); 
  519.           eval(cmd); 
  520.           disp("\nTo examine the state-space system, use the command:");
  521.           cmd = "sysout(sys3)";
  522.           disp(cmd); 
  523.           eval(cmd);
  524.           disp("\nTo examine the poles and zeros, use the command:");
  525.           cmd = "sysout(sys3,""zp"")";
  526.           disp(cmd); 
  527.           eval(cmd);
  528.           disp("\nTo convert the system to discrete time, we need a sampling");
  529.           disp("time which can be entered like this:");
  530.           cmd = "T = 0.01";
  531.           disp(cmd); 
  532.           eval(cmd);
  533.           disp("\nNow the command, c2d, is used to convert the system from");
  534.           disp("continuous to discrete time, with the following command");
  535.           cmd = "dsys3 = c2d(sys3,T);";
  536.           run_cmd;
  537.           disp("\nTo examine the new discrete state-space system, use the");
  538.           disp("command");
  539.           cmd = "sysout(dsys3);";
  540.           disp(cmd); 
  541.           eval(cmd);
  542.        disp("\nTo examine the new discrete poles and zeros, use the command:");
  543.           cmd = "sysout(dsys3,""zp"")";
  544.           disp(cmd); 
  545.           eval(cmd);
  546.           disp("\nTo view the system's nyquist plot, execute the following");
  547.           disp("commands:\n");
  548.        cmd = "gset xrange [-4:2];";
  549.           disp(cmd); eval(cmd);
  550.           cmd = "gset yrange [-2.5:2.5];";
  551.           disp(cmd); eval(cmd);
  552.           cmd = "nyquist(dsys3);";
  553.            run_cmd;
  554.       disp("Notice that the asymptotes swamp out the behavior of the plot")
  555.           disp("near the origin.  You may use interactive nyquist plots")
  556.           disp("to \"zoom in\" on a plot as follows:")
  557.  
  558.           cmd = "atol = 1;";
  559.           disp(cmd)
  560.           eval(cmd)
  561.           cmd = "nyquist(dsys3,[],[],[],atol);";
  562.           run_cmd
  563.           prompt
  564.  
  565.  
  566.           disp("")
  567.           clc
  568.           disp("MIMO SYSTEM:  Nyquist cannot be used for discrete MIMO systems");
  569.           disp("at this time.");
  570.       ## cmd = "dsys_mimo = sysgroup(sys2,dsys3);";
  571.       ## disp(cmd);
  572.       ## eval(cmd);
  573.       ## cmd = "sysout(dsys_mimo);";
  574.       ## disp(cmd);
  575.       ## eval(cmd);
  576.       ## disp("\nTo view the system's nyquist plot, execute the following command:\n")
  577.       ## cmd = "nyquist(dsys_mimo);";
  578.       ## run_cmd;       
  579.       ## prompt
  580.       ## disp("\nTo view the nyquist plots for selected  channels, the command form changes:")
  581.       ## cmd = "nyquist(dsys_mimo,[],1,1);";
  582.       ## run_cmd;
  583.       ## disp("\nNotice that this bode plot is the same as the plot from example 2.");         
  584.           prompt
  585.           closeplot
  586.  
  587.                
  588.         elseif( k2 == 3 )
  589.           disp("\nMixed system nyquist analysis\n");
  590.           disp("Nyquist exits with an error if it is passed a ""mixed"" system (one")
  591.           disp("with both continuous and discrete states).  Use c2d or d2c to")
  592.           disp("convert the system to either pure digital or pure continuous form");
  593.         endif
  594.       endwhile 
  595.     elseif (j == 3)
  596.       help nichols
  597.       prompt
  598.     endif
  599.   endwhile
  600. endfunction
  601.