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