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